@code-pushup/lighthouse-plugin 0.56.0 → 0.57.0

package/index.js

@@ -1,1632 +0,0 @@
-// packages/plugin-lighthouse/package.json
-var name = "@code-pushup/lighthouse-plugin";
-var version = "0.56.0";
-
-// packages/plugin-lighthouse/src/lib/constants.ts
-import { DEFAULT_FLAGS } from "chrome-launcher/dist/flags.js";
-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.toSorted();
-  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 || 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 tableCellValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]).default(null);
-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 nonnegativeNumberSchema = z.number().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 = nonnegativeNumberSchema.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/source.ts
-import { z as z2 } from "zod";
-var sourceFileLocationSchema = z2.object(
-  {
-    file: filePathSchema.describe("Relative path to source file in Git repo"),
-    position: z2.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" }
-);
-
-// packages/models/src/lib/audit.ts
-import { z as z3 } from "zod";
-var auditSchema = z3.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 = z3.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 z6 } from "zod";
-
-// packages/models/src/lib/issue.ts
-import { z as z4 } from "zod";
-var issueSeveritySchema = z4.enum(["info", "warning", "error"], {
-  description: "Severity level"
-});
-var issueSchema = z4.object(
-  {
-    message: z4.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 z5 } from "zod";
-var tableAlignmentSchema = z5.enum(["left", "center", "right"], {
-  description: "Cell alignment"
-});
-var tableColumnObjectSchema = z5.object({
-  key: z5.string(),
-  label: z5.string().optional(),
-  align: tableAlignmentSchema.optional()
-});
-var tableRowObjectSchema = z5.record(tableCellValueSchema, {
-  description: "Object row"
-});
-var tableRowPrimitiveSchema = z5.array(tableCellValueSchema, {
-  description: "Primitive row"
-});
-var tableSharedSchema = z5.object({
-  title: z5.string().optional().describe("Display title for table")
-});
-var tablePrimitiveSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.array(tableAlignmentSchema).optional(),
-      rows: z5.array(tableRowPrimitiveSchema)
-    },
-    { description: "Table with primitive rows and optional alignment columns" }
-  )
-);
-var tableObjectSchema = tableSharedSchema.merge(
-  z5.object(
-    {
-      columns: z5.union([
-        z5.array(tableAlignmentSchema),
-        z5.array(tableColumnObjectSchema)
-      ]).optional(),
-      rows: z5.array(tableRowObjectSchema)
-    },
-    {
-      description: "Table with object rows and optional alignment or object columns"
-    }
-  )
-);
-var tableSchema = (description = "Table information") => z5.union([tablePrimitiveSchema, tableObjectSchema], { description });
-
-// packages/models/src/lib/audit-output.ts
-var auditValueSchema = nonnegativeNumberSchema.describe("Raw numeric value");
-var auditDisplayValueSchema = z6.string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" }).optional();
-var auditDetailsSchema = z6.object(
-  {
-    issues: z6.array(issueSchema, { description: "List of findings" }).optional(),
-    table: tableSchema("Table of related findings").optional()
-  },
-  { description: "Detailed information" }
-);
-var auditOutputSchema = z6.object(
-  {
-    slug: slugSchema.describe("Reference to audit"),
-    displayValue: auditDisplayValueSchema,
-    value: auditValueSchema,
-    score: scoreSchema,
-    details: auditDetailsSchema.optional()
-  },
-  { description: "Audit information" }
-);
-var auditOutputsSchema = z6.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 z7 } 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(
-  z7.object({
-    type: z7.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(
-  z7.object({
-    isBinary: z7.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 = z7.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 z8 } from "zod";
-var commitSchema = z8.object(
-  {
-    hash: z8.string({ description: "Commit SHA (full)" }).regex(
-      /^[\da-f]{40}$/,
-      "Commit SHA should be a 40-character hexadecimal string"
-    ),
-    message: z8.string({ description: "Commit message" }),
-    date: z8.coerce.date({
-      description: "Date and time when commit was authored"
-    }),
-    author: z8.string({
-      description: "Commit author name"
-    }).trim()
-  },
-  { description: "Git commit" }
-);
-
-// packages/models/src/lib/core-config.ts
-import { z as z14 } from "zod";
-
-// packages/models/src/lib/persist-config.ts
-import { z as z9 } from "zod";
-var formatSchema = z9.enum(["json", "md"]);
-var persistConfigSchema = z9.object({
-  outputDir: filePathSchema.describe("Artifacts folder").optional(),
-  filename: fileNameSchema.describe("Artifacts file name (without extension)").optional(),
-  format: z9.array(formatSchema).optional()
-});
-
-// packages/models/src/lib/plugin-config.ts
-import { z as z12 } from "zod";
-
-// packages/models/src/lib/group.ts
-import { z as z10 } 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 = z10.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 z11 } from "zod";
-var outputTransformSchema = z11.function().args(z11.unknown()).returns(z11.union([auditOutputsSchema, z11.promise(auditOutputsSchema)]));
-var runnerConfigSchema = z11.object(
-  {
-    command: z11.string({
-      description: "Shell command to execute"
-    }),
-    args: z11.array(z11.string({ description: "Command arguments" })).optional(),
-    outputFile: filePathSchema.describe("Output path"),
-    outputTransform: outputTransformSchema.optional()
-  },
-  {
-    description: "How to execute runner"
-  }
-);
-var onProgressSchema = z11.function().args(z11.unknown()).returns(z11.void());
-var runnerFunctionSchema = z11.function().args(onProgressSchema.optional()).returns(z11.union([auditOutputsSchema, z11.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(
-  z12.object({
-    slug: slugSchema.describe("Unique plugin slug within core config"),
-    icon: materialIconSchema
-  })
-);
-var pluginDataSchema = z12.object({
-  runner: z12.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 z13 } from "zod";
-var uploadConfigSchema = z13.object({
-  server: urlSchema.describe("URL of deployed portal API"),
-  apiKey: z13.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: z13.number({ description: "Request timeout in minutes (default is 5)" }).positive().int().optional()
-});
-
-// packages/models/src/lib/core-config.ts
-var unrefinedCoreConfigSchema = z14.object({
-  plugins: z14.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(
-    ({ categories: categories2, plugins }) => !getMissingRefsForCategories(categories2, plugins),
-    ({ categories: categories2, plugins }) => ({
-      message: missingRefsForCategoriesErrorMsg(categories2, plugins)
-    })
-  );
-}
-
-// packages/models/src/lib/implementation/constants.ts
-var DEFAULT_PERSIST_OUTPUT_DIR = ".code-pushup";
-
-// packages/models/src/lib/report.ts
-import { z as z15 } 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(
-  z15.object({
-    audits: z15.array(auditReportSchema).min(1),
-    groups: z15.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(
-  z15.object(
-    {
-      plugins: z15.array(pluginReportSchema).min(1),
-      categories: z15.array(categoryConfigSchema).optional(),
-      commit: commitSchema.describe("Git commit for which report was collected").nullable()
-    },
-    { description: "Collect output data" }
-  )
-).refine(
-  ({ categories: categories2, plugins }) => !getMissingRefsForCategories(categories2, plugins),
-  ({ categories: categories2, plugins }) => ({
-    message: missingRefsForCategoriesErrorMsg(categories2, plugins)
-  })
-);
-
-// packages/models/src/lib/reports-diff.ts
-import { z as z16 } from "zod";
-function makeComparisonSchema(schema) {
-  const sharedDescription = schema.description || "Result";
-  return z16.object({
-    before: schema.describe(`${sharedDescription} (source commit)`),
-    after: schema.describe(`${sharedDescription} (target commit)`)
-  });
-}
-function makeArraysComparisonSchema(diffSchema, resultSchema, description) {
-  return z16.object(
-    {
-      changed: z16.array(diffSchema),
-      unchanged: z16.array(resultSchema),
-      added: z16.array(resultSchema),
-      removed: z16.array(resultSchema)
-    },
-    { description }
-  );
-}
-var scorableMetaSchema = z16.object({
-  slug: slugSchema,
-  title: titleSchema,
-  docsUrl: docsUrlSchema
-});
-var scorableWithPluginMetaSchema = scorableMetaSchema.merge(
-  z16.object({
-    plugin: pluginMetaSchema.pick({ slug: true, title: true, docsUrl: true }).describe("Plugin which defines it")
-  })
-);
-var scorableDiffSchema = scorableMetaSchema.merge(
-  z16.object({
-    scores: makeComparisonSchema(scoreSchema).merge(
-      z16.object({
-        diff: z16.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(
-  z16.object({
-    values: makeComparisonSchema(auditValueSchema).merge(
-      z16.object({
-        diff: z16.number().describe("Value change (`values.after - values.before`)")
-      })
-    ).describe("Audit `value` comparison"),
-    displayValues: makeComparisonSchema(auditDisplayValueSchema).describe(
-      "Audit `displayValue` comparison"
-    )
-  })
-);
-var categoryResultSchema = scorableMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var groupResultSchema = scorableWithPluginMetaSchema.merge(
-  z16.object({ score: scoreSchema })
-);
-var auditResultSchema = scorableWithPluginMetaSchema.merge(
-  auditOutputSchema.pick({ score: true, value: true, displayValue: true })
-);
-var reportsDiffSchema = z16.object({
-  commits: makeComparisonSchema(commitSchema).nullable().describe("Commits identifying compared reports"),
-  portalUrl: urlSchema.optional().describe("Link to comparison page in Code PushUp portal"),
-  label: z16.string().optional().describe("Label (e.g. project name)"),
-  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 DEFAULT_CHROME_FLAGS = [...DEFAULT_FLAGS, "--headless"];
-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 { bold as bold9, yellow as yellow2 } from "ansis";
-
-// packages/utils/src/lib/reports/utils.ts
-import ansis from "ansis";
-import { md } from "build-md";
-
-// packages/utils/src/lib/reports/constants.ts
-var TERMINAL_WIDTH = 80;
-
-// packages/utils/src/lib/reports/utils.ts
-function formatReportScore(score) {
-  const scaledScore = score * 100;
-  const roundedScore = Math.round(scaledScore);
-  return roundedScore === 100 && score !== 1 ? Math.floor(scaledScore).toString() : roundedScore.toString();
-}
-
-// packages/utils/src/lib/file-system.ts
-import { bold, gray } from "ansis";
-import { bundleRequire } from "bundle-require";
-import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
-
-// packages/utils/src/lib/formatting.ts
-function formatBytes(bytes, decimals = 2) {
-  const positiveBytes = Math.max(bytes, 0);
-  if (positiveBytes === 0) {
-    return "0 B";
-  }
-  const k = 1024;
-  const dm = decimals < 0 ? 0 : decimals;
-  const sizes = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
-  const i = Math.floor(Math.log(positiveBytes) / Math.log(k));
-  return `${Number.parseFloat((positiveBytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
-}
-function formatDuration(duration, granularity = 0) {
-  if (duration < 1e3) {
-    return `${granularity ? duration.toFixed(granularity) : duration} ms`;
-  }
-  return `${(duration / 1e3).toFixed(2)} s`;
-}
-function truncateText(text, options) {
-  const {
-    maxChars,
-    position = "end",
-    ellipsis = "..."
-  } = typeof options === "number" ? { maxChars: options } : options;
-  if (text.length <= maxChars) {
-    return text;
-  }
-  const maxLength = maxChars - ellipsis.length;
-  switch (position) {
-    case "start":
-      return ellipsis + text.slice(-maxLength).trim();
-    case "middle":
-      const halfMaxChars = Math.floor(maxLength / 2);
-      return text.slice(0, halfMaxChars).trim() + ellipsis + text.slice(-halfMaxChars).trim();
-    case "end":
-      return text.slice(0, maxLength).trim() + ellipsis;
-  }
-}
-
-// packages/utils/src/lib/logging.ts
-import isaacs_cliui from "@isaacs/cliui";
-import { cliui } from "@poppinss/cliui";
-import { underline } from "ansis";
-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(path) {
-  const buffer = await readFile(path);
-  return buffer.toString();
-}
-async function readJsonFile(path) {
-  const text = await readTextFile(path);
-  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;
-    }
-  }
-}
-async function importModule(options) {
-  const { mod } = await bundleRequire(options);
-  if (typeof mod === "object" && "default" in mod) {
-    return mod.default;
-  }
-  return mod;
-}
-
-// 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/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/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 { black, bold as bold2, gray as gray2, green } from "ansis";
-import { MultiProgressBars } from "multi-progress-bars";
-
-// packages/utils/src/lib/reports/generate-md-report.ts
-import { MarkdownDocument as MarkdownDocument3, md as md4 } from "build-md";
-
-// packages/utils/src/lib/text-formats/constants.ts
-var NEW_LINE = "\n";
-
-// 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 bold3(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/text-formats/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(
-        (value) => value == null ? "" : String(value)
-      );
-    }
-    return columns.map(
-      ({ key }) => objectRow[key] == null ? "" : 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));
-}
-
-// 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/index.ts
-var html = {
-  bold: bold3,
-  italic,
-  code,
-  link,
-  details,
-  table
-};
-
-// packages/utils/src/lib/reports/formatting.ts
-import {
-  MarkdownDocument,
-  md as md2
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-report-categoy-section.ts
-import { MarkdownDocument as MarkdownDocument2, md as md3 } from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff.ts
-import {
-  MarkdownDocument as MarkdownDocument5,
-  md as md6
-} from "build-md";
-
-// packages/utils/src/lib/reports/generate-md-reports-diff-utils.ts
-import { MarkdownDocument as MarkdownDocument4, md as md5 } from "build-md";
-
-// packages/utils/src/lib/reports/log-stdout-summary.ts
-import { bold as bold4, cyan, cyanBright, green as green2, red } from "ansis";
-
-// 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 path = typeof value === "string" ? value : value.path;
-  const module = await import(`lighthouse/core/audits/${path}.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,
-  saveAssets: false,
-  chromeFlags: DEFAULT_CHROME_FLAGS,
-  port: 0,
-  hostname: "127.0.0.1",
-  view: false,
-  channel: "cli",
-  // custom overwrites in favour of the plugin
-  // hide logs by default
-  quiet: true,
-  onlyAudits: [],
-  skipAudits: [],
-  onlyCategories: [],
-  output: ["json"],
-  outputPath: join2(LIGHTHOUSE_OUTPUT_PATH, LIGHTHOUSE_REPORT_NAME)
-};
-
-// packages/plugin-lighthouse/src/lib/runner/utils.ts
-import { bold as bold8 } from "ansis";
-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";
-
-// packages/plugin-lighthouse/src/lib/runner/details/details.ts
-import { bold as bold7, yellow } from "ansis";
-
-// packages/plugin-lighthouse/src/lib/runner/details/item-value.ts
-import { bold as bold5 } from "ansis";
-function trimSlice(item, maxLength = 0) {
-  const str = String(item).trim();
-  return maxLength > 0 ? str.slice(0, maxLength) : str;
-}
-function parseNodeValue(node) {
-  const { selector = "" } = node ?? {};
-  return selector;
-}
-function formatTableItemPropertyValue(itemValue, itemValueFormat) {
-  if (itemValue == null) {
-    return "";
-  }
-  if (itemValueFormat == null) {
-    if (typeof itemValue === "string") {
-      return trimSlice(itemValue);
-    }
-    if (typeof itemValue === "number") {
-      return Number(itemValue);
-    }
-    if (typeof itemValue === "boolean") {
-      return itemValue;
-    }
-  }
-  const parsedItemValue = parseTableItemPropertyValue(itemValue);
-  switch (itemValueFormat) {
-    case "bytes":
-      return formatBytes(Number(parsedItemValue));
-    case "code":
-      return html.code(trimSlice(parsedItemValue));
-    case "link":
-      const link3 = parsedItemValue;
-      return html.link(link3.url, link3.text);
-    case "url":
-      const url = parsedItemValue;
-      return html.link(url);
-    case "timespanMs":
-    case "ms":
-      return formatDuration(Number(parsedItemValue));
-    case "node":
-      return parseNodeValue(itemValue);
-    case "source-location":
-      return truncateText(String(parsedItemValue), 200);
-    case "numeric":
-      const num = Number(parsedItemValue);
-      if (num.toFixed(3).toString().endsWith(".000")) {
-        return String(num);
-      }
-      return String(num.toFixed(3));
-    case "text":
-      return truncateText(String(parsedItemValue), 500);
-    case "multi":
-      ui().logger.info(`Format type ${bold5("multi")} is not implemented`);
-      return "";
-    case "thumbnail":
-      ui().logger.info(`Format type ${bold5("thumbnail")} is not implemented`);
-      return "";
-  }
-  return itemValue;
-}
-function parseSimpleItemValue(item) {
-  if (typeof item === "object") {
-    const value = item.value;
-    if (typeof value === "object") {
-      return value.formattedDefault;
-    }
-    return value;
-  }
-  return item;
-}
-function parseTableItemPropertyValue(itemValue) {
-  if (itemValue == null) {
-    return "";
-  }
-  if (typeof itemValue === "string" || typeof itemValue === "number" || typeof itemValue === "boolean") {
-    return parseSimpleItemValue(itemValue);
-  }
-  const objectValue = itemValue;
-  const { type } = objectValue;
-  switch (type) {
-    case "code":
-    case "url":
-      return String(parseSimpleItemValue(objectValue));
-    case "node":
-      return parseNodeValue(objectValue);
-    case "link":
-      return objectValue;
-    case "numeric":
-      return Number(parseSimpleItemValue(objectValue));
-    case "source-location":
-      const { url } = objectValue;
-      return String(url);
-    case "subitems":
-      ui().logger.info(`Value type ${bold5("subitems")} is not implemented`);
-      return "";
-    case "debugdata":
-      ui().logger.info(`Value type ${bold5("debugdata")} is not implemented`, {
-        silent: true
-      });
-      return "";
-  }
-  return parseSimpleItemValue(objectValue);
-}
-
-// packages/plugin-lighthouse/src/lib/runner/details/utils.ts
-import { bold as bold6 } from "ansis";
-var LighthouseAuditDetailsParsingError = class extends Error {
-  constructor(type, rawTable, error) {
-    super(
-      `Parsing lighthouse report details ${bold6(
-        type
-      )} failed: 
-Raw data:
- ${JSON.stringify(rawTable, null, 2)}
-${error}`
-    );
-  }
-};
-
-// packages/plugin-lighthouse/src/lib/runner/details/table.type.ts
-function parseTableToAuditDetailsTable(details2) {
-  const { headings: rawHeadings, items } = details2;
-  if (items.length === 0) {
-    return void 0;
-  }
-  try {
-    return tableSchema().parse({
-      columns: parseTableColumns(rawHeadings),
-      rows: items.map((row) => parseTableRow(row, rawHeadings))
-    });
-  } catch (error) {
-    throw new LighthouseAuditDetailsParsingError(
-      "table",
-      { items, headings: rawHeadings },
-      error.message.toString()
-    );
-  }
-}
-function parseTableColumns(rawHeadings) {
-  return rawHeadings.map(({ key, label }) => ({
-    key: key ?? "",
-    ...typeof label === "string" && label.length > 0 ? { label } : {},
-    align: "left"
-  }));
-}
-function parseTableRow(tableItem, headings) {
-  const keys = new Set(headings.map(({ key }) => key));
-  const valueTypesByKey = new Map(
-    headings.map(({ key, valueType }) => [key, valueType])
-  );
-  return Object.fromEntries(
-    Object.entries(tableItem).filter(([key]) => keys.has(key)).map(([key, value]) => {
-      const valueType = valueTypesByKey.get(key);
-      return parseTableEntry([key, value], valueType);
-    })
-  );
-}
-function parseTableEntry([key, value], valueType) {
-  if (value == null) {
-    return [key, value];
-  }
-  return [key, formatTableItemPropertyValue(value, valueType)];
-}
-
-// packages/plugin-lighthouse/src/lib/runner/details/opportunity.type.ts
-function parseOpportunityToAuditDetailsTable(details2) {
-  const { headings: rawHeadings, items } = details2;
-  if (items.length === 0) {
-    return void 0;
-  }
-  try {
-    return tableSchema().parse({
-      title: "Opportunity",
-      columns: parseTableColumns(rawHeadings),
-      rows: items.map((row) => parseOpportunityItemToTableRow(row, rawHeadings))
-    });
-  } catch (error) {
-    throw new LighthouseAuditDetailsParsingError(
-      "opportunity",
-      { items, headings: rawHeadings },
-      error.message.toString()
-    );
-  }
-}
-function parseOpportunityItemToTableRow(opportunityItem, headings) {
-  const keys = new Set(headings.map(({ key }) => key));
-  const valueTypesByKey = new Map(
-    headings.map(({ key, valueType }) => [key, valueType])
-  );
-  return {
-    ...Object.fromEntries(
-      Object.entries(opportunityItem).filter(([key]) => keys.has(key)).map(([key, value]) => {
-        const valueType = valueTypesByKey.get(key);
-        return parseOpportunityEntry([key, value], valueType);
-      })
-    )
-  };
-}
-function parseOpportunityEntry([key, value], valueType) {
-  switch (key) {
-    case "url":
-      return [key, html.link(String(value))];
-    case "wastedPercent":
-      return [key, `${Number(value).toFixed(2)} %`];
-    case "totalBytes":
-    case "wastedBytes":
-      return [key, formatBytes(Number(value))];
-    case "wastedMs":
-      return [key, formatDuration(Number(value))];
-    default:
-      return parseTableEntry([key, value], valueType);
-  }
-}
-
-// packages/plugin-lighthouse/src/lib/runner/details/details.ts
-function toAuditDetails(details2) {
-  if (details2 == null) {
-    return {};
-  }
-  const { type } = details2;
-  switch (type) {
-    case "table":
-      const table2 = parseTableToAuditDetailsTable(details2);
-      return table2 ? { table: table2 } : {};
-    case "opportunity":
-      const opportunity = parseOpportunityToAuditDetailsTable(details2);
-      return opportunity ? { table: opportunity } : {};
-  }
-  return {};
-}
-var unsupportedDetailTypes = /* @__PURE__ */ new Set([
-  "debugdata",
-  "treemap-data",
-  "screenshot",
-  "filmstrip",
-  "criticalrequestchain"
-]);
-function logUnsupportedDetails(lhrAudits, { displayCount = 3 } = {}) {
-  const slugsWithDetailParsingErrors = [
-    ...new Set(
-      lhrAudits.filter(
-        ({ details: details2 }) => unsupportedDetailTypes.has(details2?.type)
-      ).map(({ details: details2 }) => details2?.type)
-    )
-  ];
-  if (slugsWithDetailParsingErrors.length > 0) {
-    const postFix = (count) => count > displayCount ? ` and ${count - displayCount} more.` : "";
-    ui().logger.debug(
-      `${yellow("\u26A0")} Plugin ${bold7(
-        PLUGIN_SLUG
-      )} skipped parsing of unsupported audit details: ${bold7(
-        slugsWithDetailParsingErrors.slice(0, displayCount).join(", ")
-      )}${postFix(slugsWithDetailParsingErrors.length)}`
-    );
-  }
-}
-
-// packages/plugin-lighthouse/src/lib/runner/utils.ts
-function normalizeAuditOutputs(auditOutputs, flags = { skipAudits: [] }) {
-  const toSkip = new Set(flags.skipAudits ?? []);
-  return auditOutputs.filter(({ slug }) => !toSkip.has(slug));
-}
-var LighthouseAuditParsingError = class extends Error {
-  constructor(slug, error) {
-    super(`
-Audit ${bold8(slug)} failed parsing details: 
-${error.message}`);
-  }
-};
-function formatBaseAuditOutput(lhrAudit) {
-  const {
-    id: slug,
-    score,
-    numericValue,
-    displayValue,
-    scoreDisplayMode
-  } = lhrAudit;
-  return {
-    slug,
-    score: score ?? 1,
-    value: numericValue ?? score ?? 0,
-    displayValue: displayValue ?? (scoreDisplayMode === "binary" ? score === 1 ? "passed" : "failed" : score ? `${formatReportScore(score)}%` : void 0)
-  };
-}
-function processAuditDetails(auditOutput, details2) {
-  try {
-    const parsedDetails = toAuditDetails(details2);
-    return Object.keys(parsedDetails).length > 0 ? { ...auditOutput, details: parsedDetails } : auditOutput;
-  } catch (error) {
-    throw new LighthouseAuditParsingError(auditOutput.slug, error);
-  }
-}
-function toAuditOutputs(lhrAudits, { verbose = false } = {}) {
-  if (verbose) {
-    logUnsupportedDetails(lhrAudits);
-  }
-  return lhrAudits.map((audit) => {
-    const auditOutput = formatBaseAuditOutput(audit);
-    return audit.details == null ? auditOutput : processAuditDetails(auditOutput, audit.details);
-  });
-}
-function determineAndSetLogLevel({
-  verbose,
-  quiet
-} = {}) {
-  let logLevel = "info";
-  if (verbose) {
-    logLevel = "verbose";
-  } else if (quiet) {
-    logLevel = "silent";
-  }
-  log.setLevel(logLevel);
-  return logLevel;
-}
-async function getConfig(options = {}) {
-  const { configPath: filepath, preset } = options;
-  if (filepath != null) {
-    if (filepath.endsWith(".json")) {
-      return readJsonFile(filepath);
-    } else if (/\.(ts|js|mjs)$/.test(filepath)) {
-      return importModule({ filepath, format: "esm" });
-    } 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;
-}
-
-// packages/plugin-lighthouse/src/lib/runner/runner.ts
-function createRunnerFunction(urlUnderTest, flags = DEFAULT_CLI_FLAGS) {
-  return async () => {
-    const {
-      configPath,
-      preset,
-      outputPath,
-      ...parsedFlags
-    } = flags;
-    const logLevel = determineAndSetLogLevel(parsedFlags);
-    const config = await getConfig({ configPath, preset });
-    if (outputPath) {
-      await ensureDirectoryExists(dirname(outputPath));
-    }
-    const enrichedFlags = {
-      ...parsedFlags,
-      logLevel,
-      outputPath
-    };
-    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]).filter(([_, v]) => !(Array.isArray(v) && v.length === 0)).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(
-      `${yellow2("\u26A0")} Plugin ${bold9(
-        LIGHTHOUSE_PLUGIN_SLUG
-      )} used unsupported flags: ${bold9(
-        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,
-    packageName: name,
-    version,
-    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 {
-  DEFAULT_CHROME_FLAGS,
-  LIGHTHOUSE_OUTPUT_PATH,
-  LIGHTHOUSE_PLUGIN_SLUG,
-  LIGHTHOUSE_REPORT_NAME,
-  src_default as default,
-  lighthouseAuditRef,
-  lighthouseGroupRef,
-  lighthousePlugin
-};