@code-pushup/lighthouse-plugin 0.42.0

package/index.js

@@ -0,0 +1,1530 @@
+// packages/plugin-lighthouse/src/lib/constants.ts
+import { join } from "node:path";
+
+// packages/models/src/lib/implementation/schemas.ts
+import { MATERIAL_ICONS } from "vscode-material-icons";
+import { z } from "zod";
+
+// packages/models/src/lib/implementation/limits.ts
+var MAX_SLUG_LENGTH = 128;
+var MAX_TITLE_LENGTH = 256;
+var MAX_DESCRIPTION_LENGTH = 65536;
+var MAX_ISSUE_MESSAGE_LENGTH = 1024;
+
+// packages/models/src/lib/implementation/utils.ts
+var slugRegex = /^[a-z\d]+(?:-[a-z\d]+)*$/;
+var filenameRegex = /^(?!.*[ \\/:*?"<>|]).+$/;
+function hasDuplicateStrings(strings) {
+  const sortedStrings = [...strings].sort();
+  const duplStrings = sortedStrings.filter(
+    (item, index) => index !== 0 && item === sortedStrings[index - 1]
+  );
+  return duplStrings.length === 0 ? false : [...new Set(duplStrings)];
+}
+function hasMissingStrings(toCheck, existing) {
+  const nonExisting = toCheck.filter((s) => !existing.includes(s));
+  return nonExisting.length === 0 ? false : nonExisting;
+}
+function errorItems(items, transform = (itemArr) => itemArr.join(", ")) {
+  return transform(items || []);
+}
+function exists(value) {
+  return value != null;
+}
+function getMissingRefsForCategories(categories2, plugins) {
+  if (categories2.length === 0) {
+    return false;
+  }
+  const auditRefsFromCategory = categories2.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "audit").map(({ plugin, slug }) => `${plugin}/${slug}`)
+  );
+  const auditRefsFromPlugins = plugins.flatMap(
+    ({ audits: audits2, slug: pluginSlug }) => audits2.map(({ slug }) => `${pluginSlug}/${slug}`)
+  );
+  const missingAuditRefs = hasMissingStrings(
+    auditRefsFromCategory,
+    auditRefsFromPlugins
+  );
+  const groupRefsFromCategory = categories2.flatMap(
+    ({ refs }) => refs.filter(({ type }) => type === "group").map(({ plugin, slug }) => `${plugin}#${slug} (group)`)
+  );
+  const groupRefsFromPlugins = plugins.flatMap(
+    ({ groups, slug: pluginSlug }) => Array.isArray(groups) ? groups.map(({ slug }) => `${pluginSlug}#${slug} (group)`) : []
+  );
+  const missingGroupRefs = hasMissingStrings(
+    groupRefsFromCategory,
+    groupRefsFromPlugins
+  );
+  const missingRefs = [missingAuditRefs, missingGroupRefs].filter((refs) => Array.isArray(refs) && refs.length > 0).flat();
+  return missingRefs.length > 0 ? missingRefs : false;
+}
+function missingRefsForCategoriesErrorMsg(categories2, plugins) {
+  const missingRefs = getMissingRefsForCategories(categories2, plugins);
+  return `The following category references need to point to an audit or group: ${errorItems(
+    missingRefs
+  )}`;
+}
+
+// packages/models/src/lib/implementation/schemas.ts
+var primitiveValueSchema = z.union([z.string(), z.number()]);
+function executionMetaSchema(options = {
+  descriptionDate: "Execution start date and time",
+  descriptionDuration: "Execution duration in ms"
+}) {
+  return z.object({
+    date: z.string({ description: options.descriptionDate }),
+    duration: z.number({ description: options.descriptionDuration })
+  });
+}
+var slugSchema = z.string({ description: "Unique ID (human-readable, URL-safe)" }).regex(slugRegex, {
+  message: "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug"
+}).max(MAX_SLUG_LENGTH, {
+  message: `slug can be max ${MAX_SLUG_LENGTH} characters long`
+});
+var descriptionSchema = z.string({ description: "Description (markdown)" }).max(MAX_DESCRIPTION_LENGTH).optional();
+var urlSchema = z.string().url();
+var docsUrlSchema = urlSchema.optional().or(z.literal("")).describe("Documentation site");
+var titleSchema = z.string({ description: "Descriptive name" }).max(MAX_TITLE_LENGTH);
+var scoreSchema = z.number({
+  description: "Value between 0 and 1"
+}).min(0).max(1);
+function metaSchema(options) {
+  const {
+    descriptionDescription,
+    titleDescription,
+    docsUrlDescription,
+    description
+  } = options ?? {};
+  return z.object(
+    {
+      title: titleDescription ? titleSchema.describe(titleDescription) : titleSchema,
+      description: descriptionDescription ? descriptionSchema.describe(descriptionDescription) : descriptionSchema,
+      docsUrl: docsUrlDescription ? docsUrlSchema.describe(docsUrlDescription) : docsUrlSchema
+    },
+    { description }
+  );
+}
+var filePathSchema = z.string().trim().min(1, { message: "path is invalid" });
+var fileNameSchema = z.string().trim().regex(filenameRegex, {
+  message: `The filename has to be valid`
+}).min(1, { message: "file name is invalid" });
+var positiveIntSchema = z.number().int().positive();
+var nonnegativeIntSchema = z.number().int().nonnegative();
+function packageVersionSchema(options) {
+  const { versionDescription = "NPM version of the package", required } = options ?? {};
+  const packageSchema = z.string({ description: "NPM package name" });
+  const versionSchema = z.string({ description: versionDescription });
+  return z.object(
+    {
+      packageName: required ? packageSchema : packageSchema.optional(),
+      version: required ? versionSchema : versionSchema.optional()
+    },
+    { description: "NPM package name and version of a published package" }
+  );
+}
+var weightSchema = nonnegativeIntSchema.describe(
+  "Coefficient for the given score (use weight 0 if only for display)"
+);
+function weightedRefSchema(description, slugDescription) {
+  return z.object(
+    {
+      slug: slugSchema.describe(slugDescription),
+      weight: weightSchema.describe("Weight used to calculate score")
+    },
+    { description }
+  );
+}
+function scorableSchema(description, refSchema, duplicateCheckFn, duplicateMessageFn) {
+  return z.object(
+    {
+      slug: slugSchema.describe('Human-readable unique ID, e.g. "performance"'),
+      refs: z.array(refSchema).min(1).refine(
+        (refs) => !duplicateCheckFn(refs),
+        (refs) => ({
+          message: duplicateMessageFn(refs)
+        })
+      ).refine(hasNonZeroWeightedRef, () => ({
+        message: "In a category there has to be at least one ref with weight > 0"
+      }))
+    },
+    { description }
+  );
+}
+var materialIconSchema = z.enum(MATERIAL_ICONS, {
+  description: "Icon from VSCode Material Icons extension"
+});
+function hasNonZeroWeightedRef(refs) {
+  return refs.reduce((acc, { weight }) => weight + acc, 0) !== 0;
+}
+
+// packages/models/src/lib/audit.ts
+import { z as z2 } from "zod";
+var auditSchema = z2.object({
+  slug: slugSchema.describe("ID (unique within plugin)")
+}).merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Link to documentation (rationale)",
+    description: "List of scorable metrics for the given plugin"
+  })
+);
+var pluginAuditsSchema = z2.array(auditSchema, {
+  description: "List of audits maintained in a plugin"
+}).min(1).refine(
+  (auditMetadata) => !getDuplicateSlugsInAudits(auditMetadata),
+  (auditMetadata) => ({
+    message: duplicateSlugsInAuditsErrorMsg(auditMetadata)
+  })
+);
+function duplicateSlugsInAuditsErrorMsg(audits2) {
+  const duplicateRefs = getDuplicateSlugsInAudits(audits2);
+  return `In plugin audits the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits(audits2) {
+  return hasDuplicateStrings(audits2.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/audit-output.ts
+import { z as z5 } from "zod";
+
+// packages/models/src/lib/issue.ts
+import { z as z3 } from "zod";
+var sourceFileLocationSchema = z3.object(
+  {
+    file: filePathSchema.describe("Relative path to source file in Git repo"),
+    position: z3.object(
+      {
+        startLine: positiveIntSchema.describe("Start line"),
+        startColumn: positiveIntSchema.describe("Start column").optional(),
+        endLine: positiveIntSchema.describe("End line").optional(),
+        endColumn: positiveIntSchema.describe("End column").optional()
+      },
+      { description: "Location in file" }
+    ).optional()
+  },
+  { description: "Source file location" }
+);
+var issueSeveritySchema = z3.enum(["info", "warning", "error"], {
+  description: "Severity level"
+});
+var issueSchema = z3.object(
+  {
+    message: z3.string({ description: "Descriptive error message" }).max(MAX_ISSUE_MESSAGE_LENGTH),
+    severity: issueSeveritySchema,
+    source: sourceFileLocationSchema.optional()
+  },
+  { description: "Issue information" }
+);
+
+// packages/models/src/lib/table.ts
+import { z as z4 } from "zod";
+var tableAlignmentSchema = z4.enum(["left", "center", "right"], {
+  description: "Cell alignment"
+});
+var tableColumnObjectSchema = z4.object({
+  key: z4.string(),
+  label: z4.string().optional(),
+  align: tableAlignmentSchema.optional()
+});
+var tableRowObjectSchema = z4.record(primitiveValueSchema, {
+  description: "Object row"
+});
+var tableRowPrimitiveSchema = z4.array(primitiveValueSchema, {
+  description: "Primitive row"
+});
+var tableSharedSchema = z4.object({
+  title: z4.string().optional().describe("Display title for table")
+});
+var tablePrimitiveSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.array(tableAlignmentSchema).optional(),
+      rows: z4.array(tableRowPrimitiveSchema)
+    },
+    { description: "Table with primitive rows and optional alignment columns" }
+  )
+);
+var tableObjectSchema = tableSharedSchema.merge(
+  z4.object(
+    {
+      columns: z4.union([
+        z4.array(tableAlignmentSchema),
+        z4.array(tableColumnObjectSchema)
+      ]).optional(),
+      rows: z4.array(tableRowObjectSchema)
+    },
+    {
+      description: "Table with object rows and optional alignment or object columns"
+    }
+  )
+);
+var tableSchema = (description = "Table information") => z4.union([tablePrimitiveSchema, tableObjectSchema], { description });
+
+// packages/models/src/lib/audit-output.ts
+var auditValueSchema = nonnegativeIntSchema.describe("Raw numeric value");
+var auditDisplayValueSchema = z5.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
+var auditDetailsSchema = z5.object(
+  {
+    issues: z5.array(issueSchema, { description: "List of findings" }).optional(),
+    table: tableSchema("Table of related findings").optional()
+  },
+  { description: "Detailed information" }
+);
+var auditOutputSchema = z5.object(
+  {
+    slug: slugSchema.describe("Reference to audit"),
+    displayValue: auditDisplayValueSchema,
+    value: auditValueSchema,
+    score: scoreSchema,
+    details: auditDetailsSchema.optional()
+  },
+  { description: "Audit information" }
+);
+var auditOutputsSchema = z5.array(auditOutputSchema, {
+  description: "List of JSON formatted audit output emitted by the runner process of a plugin"
+}).refine(
+  (audits2) => !getDuplicateSlugsInAudits2(audits2),
+  (audits2) => ({ message: duplicateSlugsInAuditsErrorMsg2(audits2) })
+);
+function duplicateSlugsInAuditsErrorMsg2(audits2) {
+  const duplicateRefs = getDuplicateSlugsInAudits2(audits2);
+  return `In plugin audits the slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInAudits2(audits2) {
+  return hasDuplicateStrings(audits2.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/category-config.ts
+import { z as z6 } from "zod";
+var categoryRefSchema = weightedRefSchema(
+  "Weighted references to audits and/or groups for the category",
+  "Slug of an audit or group (depending on `type`)"
+).merge(
+  z6.object({
+    type: z6.enum(["audit", "group"], {
+      description: "Discriminant for reference kind, affects where `slug` is looked up"
+    }),
+    plugin: slugSchema.describe(
+      "Plugin slug (plugin should contain referenced audit or group)"
+    )
+  })
+);
+var categoryConfigSchema = scorableSchema(
+  "Category with a score calculated from audits and groups from various plugins",
+  categoryRefSchema,
+  getDuplicateRefsInCategoryMetrics,
+  duplicateRefsInCategoryMetricsErrorMsg
+).merge(
+  metaSchema({
+    titleDescription: "Category Title",
+    docsUrlDescription: "Category docs URL",
+    descriptionDescription: "Category description",
+    description: "Meta info for category"
+  })
+).merge(
+  z6.object({
+    isBinary: z6.boolean({
+      description: 'Is this a binary category (i.e. only a perfect score considered a "pass")?'
+    }).optional()
+  })
+);
+function duplicateRefsInCategoryMetricsErrorMsg(metrics) {
+  const duplicateRefs = getDuplicateRefsInCategoryMetrics(metrics);
+  return `In the categories, the following audit or group refs are duplicates: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInCategoryMetrics(metrics) {
+  return hasDuplicateStrings(
+    metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`)
+  );
+}
+var categoriesSchema = z6.array(categoryConfigSchema, {
+  description: "Categorization of individual audits"
+}).refine(
+  (categoryCfg) => !getDuplicateSlugCategories(categoryCfg),
+  (categoryCfg) => ({
+    message: duplicateSlugCategoriesErrorMsg(categoryCfg)
+  })
+);
+function duplicateSlugCategoriesErrorMsg(categories2) {
+  const duplicateStringSlugs = getDuplicateSlugCategories(categories2);
+  return `In the categories, the following slugs are duplicated: ${errorItems(
+    duplicateStringSlugs
+  )}`;
+}
+function getDuplicateSlugCategories(categories2) {
+  return hasDuplicateStrings(categories2.map(({ slug }) => slug));
+}
+
+// packages/models/src/lib/commit.ts
+import { z as z7 } from "zod";
+var commitSchema = z7.object(
+  {
+    hash: z7.string({ description: "Commit SHA (full)" }).regex(
+      /^[\da-f]{40}$/,
+      "Commit SHA should be a 40-character hexadecimal string"
+    ),
+    message: z7.string({ description: "Commit message" }),
+    date: z7.coerce.date({
+      description: "Date and time when commit was authored"
+    }),
+    author: z7.string({
+      description: "Commit author name"
+    }).trim()
+  },
+  { description: "Git commit" }
+);
+
+// packages/models/src/lib/core-config.ts
+import { z as z13 } from "zod";
+
+// packages/models/src/lib/persist-config.ts
+import { z as z8 } from "zod";
+var formatSchema = z8.enum(["json", "md"]);
+var persistConfigSchema = z8.object({
+  outputDir: filePathSchema.describe("Artifacts folder").optional(),
+  filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
+  format: z8.array(formatSchema).optional()
+});
+
+// packages/models/src/lib/plugin-config.ts
+import { z as z11 } from "zod";
+
+// packages/models/src/lib/group.ts
+import { z as z9 } from "zod";
+var groupRefSchema = weightedRefSchema(
+  "Weighted reference to a group",
+  "Reference slug to a group within this plugin (e.g. 'max-lines')"
+);
+var groupMetaSchema = metaSchema({
+  titleDescription: "Descriptive name for the group",
+  descriptionDescription: "Description of the group (markdown)",
+  docsUrlDescription: "Group documentation site",
+  description: "Group metadata"
+});
+var groupSchema = scorableSchema(
+  'A group aggregates a set of audits into a single score which can be referenced from a category. E.g. the group slug "performance" groups audits and can be referenced in a category',
+  groupRefSchema,
+  getDuplicateRefsInGroups,
+  duplicateRefsInGroupsErrorMsg
+).merge(groupMetaSchema);
+var groupsSchema = z9.array(groupSchema, {
+  description: "List of groups"
+}).optional().refine(
+  (groups) => !getDuplicateSlugsInGroups(groups),
+  (groups) => ({
+    message: duplicateSlugsInGroupsErrorMsg(groups)
+  })
+);
+function duplicateRefsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateRefsInGroups(groups);
+  return `In plugin groups the following references are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateRefsInGroups(groups) {
+  return hasDuplicateStrings(groups.map(({ slug: ref }) => ref).filter(exists));
+}
+function duplicateSlugsInGroupsErrorMsg(groups) {
+  const duplicateRefs = getDuplicateSlugsInGroups(groups);
+  return `In groups the following slugs are not unique: ${errorItems(
+    duplicateRefs
+  )}`;
+}
+function getDuplicateSlugsInGroups(groups) {
+  return Array.isArray(groups) ? hasDuplicateStrings(groups.map(({ slug }) => slug)) : false;
+}
+
+// packages/models/src/lib/runner-config.ts
+import { z as z10 } from "zod";
+var outputTransformSchema = z10.function().args(z10.unknown()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
+var runnerConfigSchema = z10.object(
+  {
+    command: z10.string({
+      description: "Shell command to execute"
+    }),
+    args: z10.array(z10.string({ description: "Command arguments" })).optional(),
+    outputFile: filePathSchema.describe("Output path"),
+    outputTransform: outputTransformSchema.optional()
+  },
+  {
+    description: "How to execute runner"
+  }
+);
+var onProgressSchema = z10.function().args(z10.unknown()).returns(z10.void());
+var runnerFunctionSchema = z10.function().args(onProgressSchema.optional()).returns(z10.union([auditOutputsSchema, z10.promise(auditOutputsSchema)]));
+
+// packages/models/src/lib/plugin-config.ts
+var pluginMetaSchema = packageVersionSchema().merge(
+  metaSchema({
+    titleDescription: "Descriptive name",
+    descriptionDescription: "Description (markdown)",
+    docsUrlDescription: "Plugin documentation site",
+    description: "Plugin metadata"
+  })
+).merge(
+  z11.object({
+    slug: slugSchema.describe("Unique plugin slug within core config"),
+    icon: materialIconSchema
+  })
+);
+var pluginDataSchema = z11.object({
+  runner: z11.union([runnerConfigSchema, runnerFunctionSchema]),
+  audits: pluginAuditsSchema,
+  groups: groupsSchema
+});
+var pluginConfigSchema = pluginMetaSchema.merge(pluginDataSchema).refine(
+  (pluginCfg) => !getMissingRefsFromGroups(pluginCfg),
+  (pluginCfg) => ({
+    message: missingRefsFromGroupsErrorMsg(pluginCfg)
+  })
+);
+function missingRefsFromGroupsErrorMsg(pluginCfg) {
+  const missingRefs = getMissingRefsFromGroups(pluginCfg);
+  return `The following group references need to point to an existing audit in this plugin config: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups(pluginCfg) {
+  return hasMissingStrings(
+    pluginCfg.groups?.flatMap(
+      ({ refs: audits2 }) => audits2.map(({ slug: ref }) => ref)
+    ) ?? [],
+    pluginCfg.audits.map(({ slug }) => slug)
+  );
+}
+
+// packages/models/src/lib/upload-config.ts
+import { z as z12 } from "zod";
+var uploadConfigSchema = z12.object({
+  server: urlSchema.describe("URL of deployed portal API"),
+  apiKey: z12.string({
+    description: "API key with write access to portal (use `process.env` for security)"
+  }),
+  organization: slugSchema.describe(
+    "Organization slug from Code PushUp portal"
+  ),
+  project: slugSchema.describe("Project slug from Code PushUp portal"),
+  timeout: z12.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
+});
+
+// packages/models/src/lib/core-config.ts
+var unrefinedCoreConfigSchema = z13.object({
+  plugins: z13.array(pluginConfigSchema, {
+    description: "List of plugins to be used (official, community-provided, or custom)"
+  }).min(1),
+  /** portal configuration for persisting results */
+  persist: persistConfigSchema.optional(),
+  /** portal configuration for uploading results */
+  upload: uploadConfigSchema.optional(),
+  categories: categoriesSchema.optional()
+});
+var coreConfigSchema = refineCoreConfig(unrefinedCoreConfigSchema);
+function refineCoreConfig(schema) {
+  return schema.refine(
+    (coreCfg) => !getMissingRefsForCategories(coreCfg.categories ?? [], coreCfg.plugins),
+    (coreCfg) => ({
+      message: missingRefsForCategoriesErrorMsg(
+        coreCfg.categories ?? [],
+        coreCfg.plugins
+      )
+    })
+  );
+}
+
+// packages/models/src/lib/implementation/constants.ts
+var DEFAULT_PERSIST_OUTPUT_DIR = ".code-pushup";
+
+// packages/models/src/lib/report.ts
+import { z as z14 } from "zod";
+var auditReportSchema = auditSchema.merge(auditOutputSchema);
+var pluginReportSchema = pluginMetaSchema.merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of plugin run",
+    descriptionDuration: "Duration of the plugin run in ms"
+  })
+).merge(
+  z14.object({
+    audits: z14.array(auditReportSchema).min(1),
+    groups: z14.array(groupSchema).optional()
+  })
+).refine(
+  (pluginReport) => !getMissingRefsFromGroups2(pluginReport.audits, pluginReport.groups ?? []),
+  (pluginReport) => ({
+    message: missingRefsFromGroupsErrorMsg2(
+      pluginReport.audits,
+      pluginReport.groups ?? []
+    )
+  })
+);
+function missingRefsFromGroupsErrorMsg2(audits2, groups) {
+  const missingRefs = getMissingRefsFromGroups2(audits2, groups);
+  return `group references need to point to an existing audit in this plugin report: ${errorItems(
+    missingRefs
+  )}`;
+}
+function getMissingRefsFromGroups2(audits2, groups) {
+  return hasMissingStrings(
+    groups.flatMap(
+      ({ refs: auditRefs }) => auditRefs.map(({ slug: ref }) => ref)
+    ),
+    audits2.map(({ slug }) => slug)
+  );
+}
+var reportSchema = packageVersionSchema({
+  versionDescription: "NPM version of the CLI",
+  required: true
+}).merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of the collect run",
+    descriptionDuration: "Duration of the collect run in ms"
+  })
+).merge(
+  z14.object(
+    {
+      categories: z14.array(categoryConfigSchema),
+      plugins: z14.array(pluginReportSchema).min(1),
+      commit: commitSchema.describe("Git commit for which report was collected").nullable()
+    },
+    { description: "Collect output data" }
+  )
+).refine(
+  (report) => !getMissingRefsForCategories(report.categories, report.plugins),
+  (report) => ({
+    message: missingRefsForCategoriesErrorMsg(
+      report.categories,
+      report.plugins
+    )
+  })
+);
+
+// packages/models/src/lib/reports-diff.ts
+import { z as z15 } from "zod";
+function makeComparisonSchema(schema) {
+  const sharedDescription = schema.description || "Result";
+  return z15.object({
+    before: schema.describe(`${sharedDescription} (source commit)`),
+    after: schema.describe(`${sharedDescription} (target commit)`)
+  });
+}
+function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
+  return z15.object(
+    {
+      changed: z15.array(diffSchema),
+      unchanged: z15.array(resultSchema),
+      added: z15.array(resultSchema),
+      removed: z15.array(resultSchema)
+    },
+    { description }
+  );
+}
+var scorableMetaSchema = z15.object({
+  slug: slugSchema,
+  title: titleSchema,
+  docsUrl: docsUrlSchema
+});
+var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
+  z15.object({
+    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
+  })
+);
+var scorableDiffSchema = scorableMetaSchema.merge(
+  z15.object({
+    scores: makeComparisonSchema(scoreSchema).merge(
+      z15.object({
+        diff: z15.number().min(-1).max(1).describe("Score change (`scores.after - scores.before`)")
+      })
+    ).describe("Score comparison")
+  })
+);
+var scorableWithPluginDiffSchema = scorableDiffSchema.merge(
+  scorableWithPluginMetaSchema
+);
+var categoryDiffSchema = scorableDiffSchema;
+var groupDiffSchema = scorableWithPluginDiffSchema;
+var auditDiffSchema = scorableWithPluginDiffSchema.merge(
+  z15.object({
+    values: makeComparisonSchema(auditValueSchema).merge(
+      z15.object({
+        diff: z15.number().int().describe("Value change (`values.after - values.before`)")
+      })
+    ).describe("Audit `value` comparison"),
+    displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
+      "Audit `displayValue` comparison"
+    )
+  })
+);
+var categoryResultSchema = scorableMetaSchema.merge(
+  z15.object({ score: scoreSchema })
+);
+var groupResultSchema = scorableWithPluginMetaSchema.merge(
+  z15.object({ score: scoreSchema })
+);
+var auditResultSchema = scorableWithPluginMetaSchema.merge(
+  auditOutputSchema.pick({ score: true, value: true, displayValue: true })
+);
+var reportsDiffSchema = z15.object({
+  commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
+  categories: makeArraysComparisonSchema(
+    categoryDiffSchema,
+    categoryResultSchema,
+    "Changes affecting categories"
+  ),
+  groups: makeArraysComparisonSchema(
+    groupDiffSchema,
+    groupResultSchema,
+    "Changes affecting groups"
+  ),
+  audits: makeArraysComparisonSchema(
+    auditDiffSchema,
+    auditResultSchema,
+    "Changes affecting audits"
+  )
+}).merge(
+  packageVersionSchema({
+    versionDescription: "NPM version of the CLI (when `compare` was run)",
+    required: true
+  })
+).merge(
+  executionMetaSchema({
+    descriptionDate: "Start date and time of the compare run",
+    descriptionDuration: "Duration of the compare run in ms"
+  })
+);
+
+// packages/plugin-lighthouse/src/lib/constants.ts
+var LIGHTHOUSE_PLUGIN_SLUG = "lighthouse";
+var LIGHTHOUSE_OUTPUT_PATH = join(
+  DEFAULT_PERSIST_OUTPUT_DIR,
+  LIGHTHOUSE_PLUGIN_SLUG
+);
+
+// packages/plugin-lighthouse/src/lib/normalize-flags.ts
+import chalk6 from "chalk";
+
+// packages/utils/src/lib/text-formats/constants.ts
+var NEW_LINE = "\n";
+var TAB = "  ";
+
+// packages/utils/src/lib/text-formats/html/details.ts
+function details(title, content, cfg = { open: false }) {
+  return `<details${cfg.open ? " open" : ""}>${NEW_LINE}<summary>${title}</summary>${NEW_LINE}${// ⚠️ The blank line is needed to ensure Markdown in content is rendered correctly.
+  NEW_LINE}${content}${NEW_LINE}${// @TODO in the future we could consider adding it only if the content ends with a code block
+  // ⚠️ The blank line ensure Markdown in content is rendered correctly.
+  NEW_LINE}</details>${// ⚠️ The blank line is needed to ensure Markdown after details is rendered correctly.
+  NEW_LINE}`;
+}
+
+// packages/utils/src/lib/text-formats/html/font-style.ts
+var boldElement = "b";
+function bold(text) {
+  return `<${boldElement}>${text}</${boldElement}>`;
+}
+var italicElement = "i";
+function italic(text) {
+  return `<${italicElement}>${text}</${italicElement}>`;
+}
+var codeElement = "code";
+function code(text) {
+  return `<${codeElement}>${text}</${codeElement}>`;
+}
+
+// packages/utils/src/lib/text-formats/html/link.ts
+function link(href, text) {
+  return `<a href="${href}">${text || href}"</a>`;
+}
+
+// packages/utils/src/lib/transform.ts
+function toArray(val) {
+  return Array.isArray(val) ? val : [val];
+}
+function capitalize(text) {
+  return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
+    1
+  )}`;
+}
+
+// packages/utils/src/lib/table.ts
+function rowToStringArray({ rows, columns = [] }) {
+  if (Array.isArray(rows.at(0)) && typeof columns.at(0) === "object") {
+    throw new TypeError(
+      "Column can`t be object when rows are primitive values"
+    );
+  }
+  return rows.map((row) => {
+    if (Array.isArray(row)) {
+      return row.map(String);
+    }
+    const objectRow = row;
+    if (columns.length === 0 || typeof columns.at(0) === "string") {
+      return Object.values(objectRow).map(String);
+    }
+    return columns.map(
+      ({ key }) => String(objectRow[key])
+    );
+  });
+}
+function columnsToStringArray({ rows, columns = [] }) {
+  const firstRow = rows.at(0);
+  const primitiveRows = Array.isArray(firstRow);
+  if (typeof columns.at(0) === "string" && !primitiveRows) {
+    throw new Error("invalid union type. Caught by model parsing.");
+  }
+  if (columns.length === 0) {
+    if (Array.isArray(firstRow)) {
+      return firstRow.map((_, idx) => String(idx));
+    }
+    return Object.keys(firstRow);
+  }
+  if (typeof columns.at(0) === "string") {
+    return columns.map(String);
+  }
+  const cols = columns;
+  return cols.map(({ label, key }) => label ?? capitalize(key));
+}
+function getColumnAlignmentForKeyAndIndex(targetKey, targetIdx, columns = []) {
+  const column = columns.at(targetIdx) ?? columns.find((col) => col.key === targetKey);
+  if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignmentForIndex(targetIdx, columns = []) {
+  const column = columns.at(targetIdx);
+  if (column == null) {
+    return "center";
+  } else if (typeof column === "string") {
+    return column;
+  } else if (typeof column === "object") {
+    return column.align ?? "center";
+  } else {
+    return "center";
+  }
+}
+function getColumnAlignments({
+  rows,
+  columns = []
+}) {
+  if (rows.at(0) == null) {
+    throw new Error("first row can`t be undefined.");
+  }
+  if (Array.isArray(rows.at(0))) {
+    const firstPrimitiveRow = rows.at(0);
+    return Array.from({ length: firstPrimitiveRow.length }).map(
+      (_, idx) => getColumnAlignmentForIndex(idx, columns)
+    );
+  }
+  const firstObject = rows.at(0);
+  return Object.keys(firstObject).map(
+    (key, idx) => getColumnAlignmentForKeyAndIndex(key, idx, columns)
+  );
+}
+
+// packages/utils/src/lib/text-formats/html/table.ts
+function wrap(elem, content) {
+  return `<${elem}>${content}</${elem}>${NEW_LINE}`;
+}
+function wrapRow(content) {
+  const elem = "tr";
+  return `<${elem}>${NEW_LINE}${content}</${elem}>${NEW_LINE}`;
+}
+function table(tableData) {
+  if (tableData.rows.length === 0) {
+    throw new Error("Data can't be empty");
+  }
+  const tableHeaderCols = columnsToStringArray(tableData).map((s) => wrap("th", s)).join("");
+  const tableHeaderRow = wrapRow(tableHeaderCols);
+  const tableBody = rowToStringArray(tableData).map((arr) => {
+    const columns = arr.map((s) => wrap("td", s)).join("");
+    return wrapRow(columns);
+  }).join("");
+  return wrap("table", `${NEW_LINE}${tableHeaderRow}${tableBody}`);
+}
+
+// packages/utils/src/lib/text-formats/md/font-style.ts
+var boldWrap = "**";
+function bold2(text) {
+  return `${boldWrap}${text}${boldWrap}`;
+}
+var italicWrap = "_";
+function italic2(text) {
+  return `${italicWrap}${text}${italicWrap}`;
+}
+var strikeThroughWrap = "~";
+function strikeThrough(text) {
+  return `${strikeThroughWrap}${text}${strikeThroughWrap}`;
+}
+var codeWrap = "`";
+function code2(text) {
+  return `${codeWrap}${text}${codeWrap}`;
+}
+
+// packages/utils/src/lib/text-formats/md/headline.ts
+function headline(text, hierarchy = 1) {
+  return `${"#".repeat(hierarchy)} ${text}${NEW_LINE}`;
+}
+function h(text, hierarchy = 1) {
+  return headline(text, hierarchy);
+}
+function h1(text) {
+  return headline(text, 1);
+}
+function h2(text) {
+  return headline(text, 2);
+}
+function h3(text) {
+  return headline(text, 3);
+}
+function h4(text) {
+  return headline(text, 4);
+}
+function h5(text) {
+  return headline(text, 5);
+}
+function h6(text) {
+  return headline(text, 6);
+}
+
+// packages/utils/src/lib/text-formats/md/image.ts
+function image(src, alt) {
+  return `![${alt}](${src})`;
+}
+
+// packages/utils/src/lib/text-formats/md/link.ts
+function link2(href, text) {
+  return `[${text || href}](${href})`;
+}
+
+// packages/utils/src/lib/text-formats/md/list.ts
+function li(text, order = "unordered") {
+  const style = order === "unordered" ? "-" : "- [ ]";
+  return `${style} ${text}`;
+}
+function indentation(text, level = 1) {
+  return `${TAB.repeat(level)}${text}`;
+}
+
+// packages/utils/src/lib/text-formats/md/paragraphs.ts
+function paragraphs(...sections) {
+  return sections.filter(Boolean).join(`${NEW_LINE}${NEW_LINE}`);
+}
+
+// packages/utils/src/lib/text-formats/md/section.ts
+function section(...contents) {
+  return `${lines(...contents)}${NEW_LINE}`;
+}
+function lines(...contents) {
+  return `${contents.filter(Boolean).join(NEW_LINE)}`;
+}
+
+// packages/utils/src/lib/text-formats/md/table.ts
+var alignString = /* @__PURE__ */ new Map([
+  ["left", ":--"],
+  ["center", ":--:"],
+  ["right", "--:"]
+]);
+function tableRow(rows) {
+  return `|${rows.join("|")}|`;
+}
+function table2(data) {
+  if (data.rows.length === 0) {
+    throw new Error("Data can't be empty");
+  }
+  const alignmentRow = getColumnAlignments(data).map(
+    (s) => alignString.get(s) ?? String(alignString.get("center"))
+  );
+  return section(
+    `${lines(
+      tableRow(columnsToStringArray(data)),
+      tableRow(alignmentRow),
+      ...rowToStringArray(data).map(tableRow)
+    )}`
+  );
+}
+
+// packages/utils/src/lib/text-formats/index.ts
+var md = {
+  bold: bold2,
+  italic: italic2,
+  strikeThrough,
+  code: code2,
+  link: link2,
+  image,
+  headline,
+  h,
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6,
+  indentation,
+  lines,
+  li,
+  section,
+  paragraphs,
+  table: table2
+};
+var html = {
+  bold,
+  italic,
+  code,
+  link,
+  details,
+  table
+};
+
+// packages/utils/src/lib/file-system.ts
+import { bundleRequire } from "bundle-require";
+import chalk2 from "chalk";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+
+// packages/utils/src/lib/logging.ts
+import isaacs_cliui from "@isaacs/cliui";
+import { cliui } from "@poppinss/cliui";
+import chalk from "chalk";
+
+// packages/utils/src/lib/reports/constants.ts
+var TERMINAL_WIDTH = 80;
+
+// packages/utils/src/lib/logging.ts
+var singletonUiInstance;
+function ui() {
+  if (singletonUiInstance === void 0) {
+    singletonUiInstance = cliui();
+  }
+  return {
+    ...singletonUiInstance,
+    row: (args) => {
+      logListItem(args);
+    }
+  };
+}
+var singletonisaacUi;
+function logListItem(args) {
+  if (singletonisaacUi === void 0) {
+    singletonisaacUi = isaacs_cliui({ width: TERMINAL_WIDTH });
+  }
+  singletonisaacUi.div(...args);
+  const content = singletonisaacUi.toString();
+  singletonisaacUi.rows = [];
+  singletonUiInstance?.logger.log(content);
+}
+
+// packages/utils/src/lib/file-system.ts
+async function readTextFile(path2) {
+  const buffer = await readFile(path2);
+  return buffer.toString();
+}
+async function readJsonFile(path2) {
+  const text = await readTextFile(path2);
+  return JSON.parse(text);
+}
+async function ensureDirectoryExists(baseDir) {
+  try {
+    await mkdir(baseDir, { recursive: true });
+    return;
+  } catch (error) {
+    ui().logger.info(error.message);
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+var NoExportError = class extends Error {
+  constructor(filepath) {
+    super(`No default export found in ${filepath}`);
+  }
+};
+async function importEsmModule(options) {
+  const { mod } = await bundleRequire({
+    format: "esm",
+    ...options
+  });
+  if (!("default" in mod)) {
+    throw new NoExportError(options.filepath);
+  }
+  return mod.default;
+}
+
+// packages/utils/src/lib/reports/utils.ts
+var { image: image2, bold: boldMd } = md;
+
+// packages/utils/src/lib/filter.ts
+function filterItemRefsBy(items, refFilterFn) {
+  return items.map((item) => ({
+    ...item,
+    refs: item.refs.filter(refFilterFn)
+  })).filter((item) => item.refs.length);
+}
+
+// packages/utils/src/lib/git/git.ts
+import { simpleGit } from "simple-git";
+
+// packages/utils/src/lib/git/git.commits-and-tags.ts
+import { simpleGit as simpleGit2 } from "simple-git";
+
+// packages/utils/src/lib/semver.ts
+import { rcompare, valid } from "semver";
+
+// packages/utils/src/lib/progress.ts
+import chalk3 from "chalk";
+import { MultiProgressBars } from "multi-progress-bars";
+
+// packages/utils/src/lib/reports/formatting.ts
+var { headline: headline2, lines: lines2, link: link3, section: section2, table: table3 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
+var { link: link4, section: section3, h2: h22, lines: lines3, li: li2, bold: boldMd2, h3: h32, indentation: indentation2 } = md;
+
+// packages/utils/src/lib/reports/generate-md-report.ts
+var { h1: h12, h2: h23, h3: h33, lines: lines4, link: link5, section: section4, code: codeMd } = md;
+var { bold: boldHtml, details: details2 } = html;
+
+// packages/utils/src/lib/reports/generate-md-reports-diff.ts
+var {
+  h1: h13,
+  h2: h24,
+  lines: lines5,
+  link: link6,
+  bold: boldMd3,
+  italic: italicMd,
+  table: table4,
+  section: section5
+} = md;
+var { details: details3 } = html;
+
+// packages/utils/src/lib/reports/log-stdout-summary.ts
+import chalk4 from "chalk";
+
+// packages/plugin-lighthouse/src/lib/runner/runner.ts
+import { runLighthouse } from "lighthouse/cli/run.js";
+import { dirname } from "node:path";
+
+// packages/plugin-lighthouse/src/lib/runner/constants.ts
+import {
+  defaultConfig
+} from "lighthouse";
+import { join as join2 } from "node:path";
+var { audits, categories } = defaultConfig;
+var allRawLighthouseAudits = await Promise.all(
+  (audits ?? []).map(loadLighthouseAudit)
+);
+var PLUGIN_SLUG = "lighthouse";
+var LIGHTHOUSE_NAVIGATION_AUDITS = allRawLighthouseAudits.filter(
+  (audit) => audit.meta.supportedModes == null || Array.isArray(audit.meta.supportedModes) && audit.meta.supportedModes.includes("navigation")
+).map((audit) => ({
+  slug: audit.meta.id,
+  title: getMetaString(audit.meta.title),
+  description: getMetaString(audit.meta.description)
+}));
+var navigationAuditSlugs = new Set(
+  LIGHTHOUSE_NAVIGATION_AUDITS.map(({ slug }) => slug)
+);
+var LIGHTHOUSE_GROUPS = Object.entries(categories ?? {}).map(
+  ([id, category]) => ({
+    slug: id,
+    title: getMetaString(category.title),
+    ...category.description && {
+      description: getMetaString(category.description)
+    },
+    refs: category.auditRefs.filter(({ id: auditSlug }) => navigationAuditSlugs.has(auditSlug)).map((ref) => ({
+      slug: ref.id,
+      weight: ref.weight
+    }))
+  })
+);
+function getMetaString(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.formattedDefault;
+}
+async function loadLighthouseAudit(value) {
+  if (typeof value === "object" && "implementation" in value) {
+    return value.implementation;
+  }
+  if (typeof value === "function") {
+    return value;
+  }
+  const path2 = typeof value === "string" ? value : value.path;
+  const module = await import(`lighthouse/core/audits/${path2}.js`);
+  return module.default;
+}
+var LIGHTHOUSE_REPORT_NAME = "lighthouse-report.json";
+var DEFAULT_CLI_FLAGS = {
+  // default values extracted from
+  // https://github.com/GoogleChrome/lighthouse/blob/7d80178c37a1b600ea8f092fc0b098029799a659/cli/cli-flags.js#L80
+  verbose: false,
+  quiet: false,
+  saveAssets: false,
+  // needed to pass CI on linux and windows (locally it works without headless too)
+  chromeFlags: ["--headless=shell"],
+  port: 0,
+  hostname: "127.0.0.1",
+  view: false,
+  channel: "cli",
+  // custom overwrites in favour of the plugin
+  onlyAudits: [],
+  skipAudits: [],
+  onlyCategories: [],
+  budgets: [],
+  output: ["json"],
+  outputPath: join2(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME)
+};
+
+// packages/plugin-lighthouse/src/lib/runner/utils.ts
+import chalk5 from "chalk";
+import log from "lighthouse-logger";
+import desktopConfig from "lighthouse/core/config/desktop-config.js";
+import experimentalConfig from "lighthouse/core/config/experimental-config.js";
+import perfConfig from "lighthouse/core/config/perf-config.js";
+import path from "node:path";
+function normalizeAuditOutputs(auditOutputs, flags = { skipAudits: [] }) {
+  const toSkip = new Set(flags.skipAudits ?? []);
+  return auditOutputs.filter(({ slug }) => {
+    const doSkip = toSkip.has(slug);
+    if (doSkip) {
+      ui().logger.info(
+        `Audit ${chalk5.bold(
+          slug
+        )} was included in audit outputs of lighthouse but listed under ${chalk5.bold(
+          "skipAudits"
+        )}.`
+      );
+    }
+    return !doSkip;
+  });
+}
+function toAuditOutputs(lhrAudits, { verbose = false } = {}) {
+  if (verbose) {
+    logUnsupportedDetails(lhrAudits);
+  }
+  return lhrAudits.map(
+    ({
+      id: slug,
+      score,
+      numericValue: value = 0,
+      // not every audit has a numericValue
+      details: details4,
+      displayValue
+    }) => {
+      const auditOutput = {
+        slug,
+        score: score ?? 1,
+        // score can be null
+        value: Number.parseInt(value.toString(), 10),
+        displayValue
+      };
+      if (details4 == null) {
+        return auditOutput;
+      }
+      return auditOutput;
+    }
+  );
+}
+var unsupportedDetailTypes = /* @__PURE__ */ new Set([
+  "opportunity",
+  "table",
+  "treemap-data",
+  "screenshot",
+  "filmstrip",
+  "debugdata",
+  "criticalrequestchain"
+]);
+function logUnsupportedDetails(lhrAudits, { displayCount = 3 } = {}) {
+  const slugsWithDetailParsingErrors = [
+    ...new Set(
+      lhrAudits.filter(
+        ({ details: details4 }) => unsupportedDetailTypes.has(details4?.type)
+      ).map(({ details: details4 }) => details4?.type)
+    )
+  ];
+  if (slugsWithDetailParsingErrors.length > 0) {
+    const postFix = (count) => count > displayCount ? ` and ${count - displayCount} more.` : "";
+    ui().logger.debug(
+      `${chalk5.yellow("\u26A0")} Plugin ${chalk5.bold(
+        PLUGIN_SLUG
+      )} skipped parsing of unsupported audit details: ${chalk5.bold(
+        slugsWithDetailParsingErrors.slice(0, displayCount).join(", ")
+      )}${postFix(slugsWithDetailParsingErrors.length)}`
+    );
+  }
+}
+function setLogLevel({
+  verbose,
+  quiet
+} = {}) {
+  if (verbose) {
+    log.setLevel("verbose");
+  } else if (quiet) {
+    log.setLevel("silent");
+  } else {
+    log.setLevel("info");
+  }
+}
+async function getConfig(options = {}) {
+  const { configPath: filepath, preset } = options;
+  if (typeof filepath === "string") {
+    if (filepath.endsWith(".json")) {
+      return readJsonFile(filepath);
+    } else if (/\.(ts|js|mjs)$/.test(filepath)) {
+      return importEsmModule({ filepath });
+    } else {
+      ui().logger.info(`Format of file ${filepath} not supported`);
+    }
+  } else if (preset != null) {
+    switch (preset) {
+      case "desktop":
+        return desktopConfig;
+      case "perf":
+        return perfConfig;
+      case "experimental":
+        return experimentalConfig;
+      default:
+        ui().logger.info(`Preset "${preset}" is not supported`);
+    }
+  }
+  return void 0;
+}
+async function getBudgets(budgetPath) {
+  if (budgetPath) {
+    return await readJsonFile(
+      path.resolve(process.cwd(), budgetPath)
+    );
+  }
+  return [];
+}
+
+// packages/plugin-lighthouse/src/lib/runner/runner.ts
+function createRunnerFunction(urlUnderTest, flags = DEFAULT_CLI_FLAGS) {
+  return async () => {
+    const {
+      configPath,
+      preset,
+      budgetPath,
+      budgets,
+      outputPath,
+      ...parsedFlags
+    } = flags;
+    setLogLevel(parsedFlags);
+    const config = await getConfig({ configPath, preset });
+    const budgetsJson = budgetPath ? await getBudgets(budgetPath) : budgets;
+    if (typeof outputPath === "string") {
+      await ensureDirectoryExists(dirname(outputPath));
+    }
+    const enrichedFlags = {
+      ...parsedFlags,
+      outputPath,
+      budgets: budgetsJson
+    };
+    const runnerResult = await runLighthouse(
+      urlUnderTest,
+      enrichedFlags,
+      config
+    );
+    if (runnerResult == null) {
+      throw new Error("Lighthouse did not produce a result.");
+    }
+    const { lhr } = runnerResult;
+    const auditOutputs = toAuditOutputs(Object.values(lhr.audits), flags);
+    return normalizeAuditOutputs(auditOutputs, enrichedFlags);
+  };
+}
+
+// packages/plugin-lighthouse/src/lib/normalize-flags.ts
+var { onlyCategories, ...originalDefaultCliFlags } = DEFAULT_CLI_FLAGS;
+var DEFAULT_LIGHTHOUSE_OPTIONS = {
+  ...originalDefaultCliFlags,
+  onlyGroups: onlyCategories
+};
+var lighthouseUnsupportedCliFlags = [
+  "precomputedLanternDataPath",
+  // Path to the file where precomputed lantern data should be read from.
+  "chromeIgnoreDefaultFlags",
+  // ignore default flags from Lighthouse CLI
+  // No error reporting implemented as in the source Sentry was involved
+  // See: https://github.com/GoogleChrome/lighthouse/blob/d8ccf70692216b7fa047a4eaa2d1277b0b7fe947/cli/bin.js#L124
+  "enableErrorReporting",
+  // enable error reporting
+  // lighthouse CLI specific debug logs
+  "list-all-audits",
+  // Prints a list of all available audits and exits.
+  "list-locales",
+  // Prints a list of all supported locales and exits.
+  "list-trace-categories"
+  // Prints a list of all required trace categories and exits.
+];
+var LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS = new Set(lighthouseUnsupportedCliFlags);
+var REFINED_STRING_OR_STRING_ARRAY = /* @__PURE__ */ new Set([
+  "onlyAudits",
+  "onlyCategories",
+  "skipAudits",
+  "budgets",
+  "chromeFlags"
+]);
+function normalizeFlags(flags) {
+  const prefilledFlags = { ...DEFAULT_LIGHTHOUSE_OPTIONS, ...flags };
+  logUnsupportedFlagsInUse(prefilledFlags);
+  return Object.fromEntries(
+    Object.entries(prefilledFlags).filter(
+      ([flagName]) => !LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(
+        flagName
+      )
+    ).map(([key, v]) => [key === "onlyGroups" ? "onlyCategories" : key, v]).map(([key, v]) => {
+      if (!REFINED_STRING_OR_STRING_ARRAY.has(key)) {
+        return [key, v];
+      }
+      return [key, Array.isArray(v) ? v : v == null ? [] : [v]];
+    })
+  );
+}
+function logUnsupportedFlagsInUse(flags, displayCount = 3) {
+  const unsupportedFlagsInUse = Object.keys(flags).filter(
+    (flag) => LIGHTHOUSE_UNSUPPORTED_CLI_FLAGS.has(flag)
+  );
+  if (unsupportedFlagsInUse.length > 0) {
+    const postFix = (count) => count > displayCount ? ` and ${count - displayCount} more.` : "";
+    ui().logger.debug(
+      `${chalk6.yellow("\u26A0")} Plugin ${chalk6.bold(
+        LIGHTHOUSE_PLUGIN_SLUG
+      )} used unsupported flags: ${chalk6.bold(
+        unsupportedFlagsInUse.slice(0, displayCount).join(", ")
+      )}${postFix(unsupportedFlagsInUse.length)}`
+    );
+  }
+}
+
+// packages/plugin-lighthouse/src/lib/utils.ts
+function lighthouseGroupRef(groupSlug, weight = 1) {
+  return {
+    plugin: LIGHTHOUSE_PLUGIN_SLUG,
+    slug: groupSlug,
+    type: "group",
+    weight
+  };
+}
+function lighthouseAuditRef(auditSlug, weight = 1) {
+  return {
+    plugin: LIGHTHOUSE_PLUGIN_SLUG,
+    slug: auditSlug,
+    type: "audit",
+    weight
+  };
+}
+var AuditsNotImplementedError = class extends Error {
+  constructor(auditSlugs) {
+    super(`audits: "${auditSlugs.join(", ")}" not implemented`);
+  }
+};
+function validateAudits(audits2, onlyAudits) {
+  const missingAudtis = toArray(onlyAudits).filter(
+    (slug) => !audits2.some((audit) => audit.slug === slug)
+  );
+  if (missingAudtis.length > 0) {
+    throw new AuditsNotImplementedError(missingAudtis);
+  }
+  return true;
+}
+var CategoriesNotImplementedError = class extends Error {
+  constructor(categorySlugs) {
+    super(`categories: "${categorySlugs.join(", ")}" not implemented`);
+  }
+};
+function validateOnlyCategories(groups, onlyCategories2) {
+  const missingCategories = toArray(onlyCategories2).filter(
+    (slug) => groups.every((group) => group.slug !== slug)
+  );
+  if (missingCategories.length > 0) {
+    throw new CategoriesNotImplementedError(missingCategories);
+  }
+  return true;
+}
+function filterAuditsAndGroupsByOnlyOptions(audits2, groups, options) {
+  const {
+    onlyAudits = [],
+    skipAudits = [],
+    onlyCategories: onlyCategories2 = []
+  } = options ?? {};
+  if (onlyCategories2.length > 0) {
+    validateOnlyCategories(groups, onlyCategories2);
+    const categorySlugs = new Set(onlyCategories2);
+    const filteredGroups = groups.filter(
+      ({ slug }) => categorySlugs.has(slug)
+    );
+    const auditSlugsFromRemainingGroups = new Set(
+      filteredGroups.flatMap(({ refs }) => refs.map(({ slug }) => slug))
+    );
+    return {
+      audits: audits2.filter(
+        ({ slug }) => auditSlugsFromRemainingGroups.has(slug)
+      ),
+      groups: filteredGroups
+    };
+  } else if (onlyAudits.length > 0 || skipAudits.length > 0) {
+    validateAudits(audits2, onlyAudits);
+    validateAudits(audits2, skipAudits);
+    const onlyAuditSlugs = new Set(onlyAudits);
+    const skipAuditSlugs = new Set(skipAudits);
+    const filterAudits = ({ slug }) => !// audit is NOT in given onlyAuditSlugs
+    (onlyAudits.length > 0 && !onlyAuditSlugs.has(slug) || // audit IS in given skipAuditSlugs
+    skipAudits.length > 0 && skipAuditSlugs.has(slug));
+    return {
+      audits: audits2.filter(filterAudits),
+      groups: filterItemRefsBy(groups, filterAudits)
+    };
+  }
+  return {
+    audits: audits2,
+    groups
+  };
+}
+
+// packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts
+function lighthousePlugin(url, flags) {
+  const {
+    skipAudits = [],
+    onlyAudits = [],
+    onlyCategories: onlyCategories2 = [],
+    ...unparsedFlags
+  } = normalizeFlags(flags ?? {});
+  const { audits: audits2, groups } = filterAuditsAndGroupsByOnlyOptions(
+    LIGHTHOUSE_NAVIGATION_AUDITS,
+    LIGHTHOUSE_GROUPS,
+    { skipAudits, onlyAudits, onlyCategories: onlyCategories2 }
+  );
+  return {
+    slug: LIGHTHOUSE_PLUGIN_SLUG,
+    title: "Lighthouse",
+    icon: "lighthouse",
+    audits: audits2,
+    groups,
+    runner: createRunnerFunction(url, {
+      skipAudits,
+      onlyAudits,
+      onlyCategories: onlyCategories2,
+      ...unparsedFlags
+    })
+  };
+}
+
+// packages/plugin-lighthouse/src/index.ts
+var src_default = lighthousePlugin;
+export {
+  LIGHTHOUSE_OUTPUT_PATH,
+  LIGHTHOUSE_PLUGIN_SLUG,
+  LIGHTHOUSE_REPORT_NAME,
+  src_default as default,
+  lighthouseAuditRef,
+  lighthouseGroupRef,
+  lighthousePlugin
+};