@redocly/replay 0.31.0-next.4 → 0.31.0-next.5

package/dist/replay-index-DVf85Dg1.js

@@ -0,0 +1,917 @@
+import { a6 as j, a7 as y } from "./replay-index-CiOV_Ucc.js";
+import { a as X, g as F, d as Q, o as Z, A as pe, S as ue, N as ee, n as N, w as I, t as de, b as ye, c as V, l as te, e as P, f as me, p as S, v as ne, k as he, h as ge, j as ve, m as E, q as O, r as se, s as be, u as D, x as M, y as x, H as Ee, z as Se, B as Oe, i as Te } from "./replay-lint-B6TsU9Uq.js";
+import { C as yt, D as mt, E as ht, F as gt, G as vt, I as bt, J as Et, K as St, L as Ot, M as Tt, O as Rt, P as xt, Q as kt, R as wt, T as Nt, U as It, V as Pt, W as Dt, X as _t, Y as Ct, Z as jt, _ as Ft, $ as Vt, a0 as Mt, a1 as $t, a2 as Lt, a3 as zt, a4 as Bt, a5 as qt, a6 as Gt, a7 as Kt, a8 as Ut, a9 as At, aa as Yt, ab as Ht, ac as Wt, ad as Jt, ae as Xt, af as Qt, ag as Zt, ah as en, ai as tn, aj as nn, ak as sn, al as rn, am as on, an, ao as cn, ap as fn, ae as ln, aq as pn } from "./replay-lint-B6TsU9Uq.js";
+import { i as Re, B as T, n as re, a as k, m as oe } from "./replay-resolve-9K6-oXdr.js";
+import { L as dn, R as yn, S as mn, Y as hn, e as gn, g as vn, b as bn, c as En, d as Sn, f as On, h as Tn, j as Rn, p as xn, k as kn, r as wn, l as Nn, s as In, u as Pn } from "./replay-resolve-9K6-oXdr.js";
+function st(e) {
+  return (j.extname(e) === ".yaml" || j.extname(e) === ".yml") && !1;
+}
+function rt(e) {
+  return y(e) && !X(e);
+}
+async function ot(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+function it(e) {
+  return e.charAt(0).toUpperCase() + e.slice(1);
+}
+const _ = "type", $ = ["api-description", "api-operation", "data-schema"];
+function xe(e, t) {
+  const { ctx: n } = F("EntityFileDefault", t), { ctx: s, discriminatorResolver: r } = F("EntityFile", e);
+  return {
+    entityTypes: {
+      ...n,
+      ...s,
+      EntityFileArray: {
+        properties: {},
+        items: (a) => {
+          if (y(a)) {
+            const i = a[_];
+            if (!i)
+              return "Entity";
+            const c = r?.(a, i);
+            if (c && typeof c == "string")
+              return c;
+          }
+          return "Entity";
+        }
+      }
+    },
+    discriminatorResolver: r
+  };
+}
+function h(e, t) {
+  if (Re(t.parent))
+    return;
+  const n = t.key.toString(), s = e.counts ??= {};
+  s[n] = (s[n] ?? 0) + 1;
+}
+function C(e) {
+  for (const r of Object.values(e))
+    r.items && (r.total = r.items.size);
+  const { xExtensions: t } = e, n = t.counts ?? {}, s = Object.keys(n).sort();
+  t.total = s.length, t.counts = Object.fromEntries(s.map((r) => [r, n[r]]));
+}
+const at = (e) => ({
+  SpecExtension: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  XCodeSampleList: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  ExamplesMap: {
+    enter(t, n) {
+      n.key.toString() === "x-examples" && h(e.xExtensions, n);
+    }
+  },
+  EnumDescriptions: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  TagGroups: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  Logo: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  XServerList: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  XUsePkce: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  Operation: {
+    enter(t, n) {
+      n.key.toString() === "x-query" && h(e.xExtensions, n);
+    }
+  },
+  ExternalDocs: {
+    leave() {
+      e.externalDocs.total++;
+    }
+  },
+  ref: {
+    enter(t) {
+      e.refs.items.add(t.$ref);
+    }
+  },
+  Tag: {
+    leave(t) {
+      e.tags.items.add(t.name);
+    }
+  },
+  Link: {
+    leave(t) {
+      e.links.items.add(t.operationId);
+    }
+  },
+  WebhooksMap: {
+    enter(t, n) {
+      n.key.toString() === "x-webhooks" && h(e.xExtensions, n);
+    },
+    Operation: {
+      leave(t) {
+        if (e.webhooks.total++, t.tags)
+          for (const n of t.tags)
+            e.tags.items.add(n);
+      }
+    }
+  },
+  Paths: {
+    PathItem: {
+      leave() {
+        e.pathItems.total++;
+      },
+      Operation: {
+        leave(t) {
+          if (e.operations.total++, t.tags)
+            for (const n of t.tags)
+              e.tags.items.add(n);
+        }
+      },
+      Parameter: {
+        leave(t) {
+          e.parameters.items.add(t.name);
+        }
+      }
+    }
+  },
+  NamedSchemas: {
+    Schema: {
+      leave() {
+        e.schemas.total++;
+      }
+    }
+  },
+  Root: {
+    leave() {
+      C(e);
+    }
+  }
+}), ct = (e) => ({
+  SpecExtension: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  ExternalDocs: {
+    leave() {
+      e.externalDocs.total++;
+    }
+  },
+  ref: {
+    enter(t) {
+      e.refs.items.add(t.$ref);
+    }
+  },
+  Tag: {
+    leave(t) {
+      e.tags.items.add(t.name);
+    }
+  },
+  ChannelMap: {
+    Channel: {
+      leave() {
+        e.channels.total++;
+      },
+      Operation: {
+        leave(t) {
+          if (e.operations.total++, t.tags)
+            for (const n of t.tags)
+              e.tags.items.add(n);
+        }
+      },
+      Parameter: {
+        leave(t, { key: n }) {
+          e.parameters.items.add(n.toString());
+        }
+      }
+    }
+  },
+  NamedSchemas: {
+    Schema: {
+      leave() {
+        e.schemas.total++;
+      }
+    }
+  },
+  Root: {
+    leave() {
+      C(e);
+    }
+  }
+}), ft = (e) => ({
+  SpecExtension: {
+    enter(t, n) {
+      h(e.xExtensions, n);
+    }
+  },
+  ExternalDocs: {
+    leave() {
+      e.externalDocs.total++;
+    }
+  },
+  ref: {
+    enter(t) {
+      e.refs.items.add(t.$ref);
+    }
+  },
+  Tag: {
+    leave(t) {
+      e.tags.items.add(t.name);
+    }
+  },
+  NamedChannels: {
+    Channel: {
+      leave() {
+        e.channels.total++;
+      },
+      Parameter: {
+        leave(t, { key: n }) {
+          e.parameters.items.add(n.toString());
+        }
+      }
+    }
+  },
+  NamedOperations: {
+    Operation: {
+      leave(t) {
+        if (e.operations.total++, t.tags)
+          for (const n of t.tags)
+            e.tags.items.add(n);
+      }
+    }
+  },
+  NamedSchemas: {
+    Schema: {
+      leave() {
+        e.schemas.total++;
+      }
+    }
+  },
+  Root: {
+    leave() {
+      C(e);
+    }
+  }
+}), ke = /^[a-z0-9]+(?:-[a-z0-9]+)*$/, L = 2, z = 150, we = () => ({
+  any(e, { report: t, location: n }) {
+    if (y(e) && "key" in e) {
+      const s = e.key;
+      if (typeof s != "string") {
+        t({
+          message: "Entity `key` must be a string.",
+          location: n.child(["key"])
+        });
+        return;
+      }
+      s.length < L && t({
+        message: `Entity 'key' must be at least ${L} characters long.`,
+        location: n.child(["key"])
+      }), s.length > z && t({
+        message: `Entity 'key' must not exceed ${z} characters.`,
+        location: n.child(["key"])
+      }), ke.test(s) || t({
+        message: "Entity `key` must contain only lowercase letters, numbers, and hyphens, and cannot start or end with a hyphen.",
+        location: n.child(["key"])
+      });
+    }
+  }
+});
+function B(e, t) {
+  const s = t.split("-").map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("") + e;
+  return Object.values(Z).includes(s) ? s : e;
+}
+function Ne(e, t) {
+  const n = {};
+  for (const [s, r] of Object.entries(t))
+    if (ie(s, r)) {
+      if (r.severity === "off")
+        continue;
+      n[s] = {
+        ..._e(e, s, r)
+      };
+    } else
+      n[s] = r;
+  return n;
+}
+function Ie(e) {
+  const t = {}, n = {};
+  for (const [s, r] of Object.entries(e))
+    if (ie(s, r)) {
+      const o = r;
+      De(o) ? t[s] = o : n[s] = o;
+    } else
+      n[s] = r;
+  return { entityRules: t, apiRules: n };
+}
+function Pe(e, t, n) {
+  if (!y(n.parsed) || !y(n.parsed.components))
+    return null;
+  const s = n.parsed.components, r = "schemas" in s ? s.schemas : void 0;
+  if (!r || !(e in r))
+    return null;
+  const o = r[e];
+  try {
+    const a = JSON.parse(t);
+    if (Q(o, a))
+      return o;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function ie(e, t) {
+  return e.startsWith("rule/") && y(t);
+}
+function De(e) {
+  return Object.values(Z).some((t) => e.subject.type === t);
+}
+function _e(e, t, n) {
+  const s = B(n.subject.type, e), r = n.where?.map((o) => ({
+    ...o,
+    subject: {
+      ...o.subject,
+      type: B(o.subject.type, e)
+    }
+  }));
+  return {
+    assertionId: t,
+    subject: {
+      ...n.subject,
+      type: s
+    },
+    assertions: n.assertions,
+    ...r && { where: r },
+    ...n.message && { message: n.message },
+    ...n.severity && { severity: n.severity }
+  };
+}
+async function Ce(e) {
+  const { document: t, entitySchema: n, entityDefaultSchema: s, severity: r, externalRefResolver: o = new T(), assertionConfig: a = {} } = e, i = {
+    problems: [],
+    specVersion: "entity",
+    visitorsData: {}
+  }, { entityTypes: c, discriminatorResolver: d } = xe(n, s), l = re(c);
+  let f = l.Entity;
+  if (Array.isArray(t.parsed))
+    f = l.EntityFileArray;
+  else if (y(t.parsed)) {
+    const v = t.parsed[_];
+    if (!v)
+      f = l.Entity;
+    else {
+      const b = d?.(t.parsed, v);
+      b && typeof b == "string" && l[b] && (f = l[b]);
+    }
+  }
+  const u = pe(a), p = Array.isArray(u) ? u.map((v) => ({
+    severity: r || "error",
+    ruleId: "entity assertions",
+    visitor: v
+  })) : [
+    {
+      severity: r || "error",
+      ruleId: "entity assertions",
+      visitor: u
+    }
+  ], m = [
+    {
+      severity: r || "error",
+      ruleId: "entity struct",
+      visitor: ue()
+    },
+    {
+      severity: r || "error",
+      ruleId: "entity no-unresolved-refs",
+      visitor: ee()
+    },
+    {
+      severity: r || "error",
+      ruleId: "entity key-valid",
+      visitor: we()
+    },
+    ...p
+  ], g = N(m, l), R = await k({
+    rootDocument: t,
+    rootType: f,
+    externalRefResolver: o
+  });
+  return I({
+    document: t,
+    rootType: f,
+    normalizedVisitors: g,
+    resolvedRefMap: R,
+    ctx: i
+  }), i.problems;
+}
+async function lt(e, t, n) {
+  if (!t.rules)
+    throw new Error(`Scorecard level "${t.name}" has no rules defined.`);
+  const s = new T(), r = oe(JSON.stringify(e, null, 2), "entity"), o = r.parsed[_], a = Ne(o || "unknown", t.rules), { entityRules: i, apiRules: c } = Ie(a), d = await Ce({
+    document: r,
+    entitySchema: de,
+    entityDefaultSchema: ye,
+    externalRefResolver: s,
+    assertionConfig: i
+  });
+  if ($.includes(e.type)) {
+    if (Object.keys(c).length === 0)
+      return d;
+    if (!n)
+      throw new Error(`Document is required for entity type "${e.type}". Provide the source API document to lint API rules.`);
+    if (e.type === "data-schema" && e.metadata?.schema) {
+      Object.values(c).forEach((p) => {
+        if (y(p) && y(p.subject) && p.subject.type !== "Schema")
+          throw new Error(`API rules for "data-schema" entity must target Schema subject, but found "${p.subject.type}".`);
+      });
+      const f = Pe(e.title, e.metadata.schema, n);
+      if (!f)
+        throw new Error(`Schema "${e.title}" not found in the document. Ensure the schema exists in components.schemas.`);
+      const u = await je({
+        schema: f,
+        schemaKey: e.title,
+        config: await V({
+          rules: c
+        }),
+        specType: e.metadata.specType,
+        sourceDocument: n,
+        externalRefResolver: s
+      });
+      return [...d, ...u];
+    }
+    const l = await te({
+      document: n,
+      externalRefResolver: s,
+      config: await V({
+        rules: c
+      })
+    });
+    return [...d, ...l];
+  } else if (!X(c))
+    throw new Error(`API rules are not supported for entity type "${e.type}". Only ${$.join(", ")} support API rules.`);
+  return d;
+}
+async function je(e) {
+  const { schema: t, schemaKey: n, config: s, sourceDocument: r, specType: o, externalRefResolver: a = new T(s.resolve) } = e, i = r.parsed, c = i[o], d = i.info, l = oe(JSON.stringify({
+    [o]: c,
+    info: d,
+    components: {
+      schemas: {
+        [n]: t
+      }
+    }
+  }, null, 2), r?.source.absoluteRef || `schema:${n}`);
+  return (await te({
+    document: l,
+    config: s,
+    externalRefResolver: a
+  })).filter((u) => u.location.some((p) => p.pointer?.includes(`/components/schemas/${n}`)));
+}
+function Fe(e) {
+  const { document: t, types: n, resolvedRefMap: s, ctx: r } = e, o = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), i = (l, { type: f, key: u, location: p }, m) => {
+    const g = {
+      type: f,
+      key: u,
+      location: p,
+      value: l,
+      parent: m ?? null,
+      children: []
+    };
+    m?.children.push(g), o.set(l, g);
+    for (const R of a.get(l) ?? [])
+      R.resolved = g;
+    return g;
+  }, d = [
+    { severity: "warn", ruleId: "node-tree", visitor: {
+      any: {
+        enter(l, f) {
+          if (!(y(l) || Array.isArray(l)) || o.has(l))
+            return;
+          const p = o.get(f.rawNode);
+          p ? i(l, f).referencedFrom = p : i(l, f, o.get(f.parent));
+        },
+        // A target the walker reached through a `$ref` before its own place joins it here
+        leave(l) {
+          const f = o.get(l);
+          if (f)
+            for (const [u, p] of Object.entries(f.value)) {
+              const m = o.get(p);
+              !m || m.parent || (m.parent = f, m.key = Array.isArray(f.value) ? Number(u) : u, f.children.push(m));
+            }
+        }
+      },
+      ref(l, f, u) {
+        if (o.has(l))
+          return;
+        const p = i(l, f, o.get(f.parent)), m = u.chain?.[0]?.node ?? u.node, g = o.get(m);
+        g ? p.resolved = g : a.set(m, [...a.get(m) ?? [], p]);
+      }
+    } },
+    { severity: "error", ruleId: "no-unresolved-refs", visitor: ee() }
+  ];
+  return I({
+    document: t,
+    rootType: n.Root,
+    normalizedVisitors: N(d, n),
+    resolvedRefMap: s,
+    ctx: r
+  }), o.get(t.parsed);
+}
+function ae(e) {
+  return e === null || typeof e == "string" || typeof e == "number" || typeof e == "boolean";
+}
+function Ve(e) {
+  return Array.isArray(e) && e.every(ae);
+}
+function Me(e) {
+  return e.kind === "removed" ? e.base : e.revision;
+}
+function $e(e) {
+  const { base: t, revision: n } = P(e);
+  if (!t)
+    return [{ path: S(e), node: e, kind: "added", revision: G(me(e)) }];
+  if (!n)
+    return [{ path: S(e), node: e, kind: "removed", base: G(t) }];
+  const s = [];
+  let r;
+  const o = q(t), a = q(n);
+  for (const i of Object.keys({ ...o, ...a }))
+    Q(o[i], a[i]) || (r ??= S(e), s.push({
+      path: r,
+      node: e,
+      kind: "modified",
+      property: i,
+      base: K(t, i, o[i]),
+      revision: K(n, i, a[i])
+    }));
+  return s;
+}
+function q(e) {
+  const t = {}, n = new Set(e.children.map((s) => s.key));
+  if (y(e.value))
+    for (const [s, r] of Object.entries(e.value))
+      n.has(s) || s === "$ref" && e.resolved || (ae(r) || Ve(r)) && (t[s] = r);
+  return t;
+}
+function G(e) {
+  return { location: e.location, value: ne(e) };
+}
+function K(e, t, n) {
+  return { location: y(e.value) && t in e.value ? e.location.child([t]) : e.location, value: n };
+}
+const Le = 0.5;
+function ze(e, t) {
+  const n = [], s = new Set(t), r = [], o = U([...e, ...t], (i) => i.value);
+  for (const i of e) {
+    const c = Be(i, s, o);
+    c ? (s.delete(c), n.push({ base: i, revision: c })) : r.push(i);
+  }
+  const a = U([...r, ...s], ne);
+  for (const i of r) {
+    const c = qe(i, s, a);
+    c && s.delete(c), n.push({ base: i, revision: c });
+  }
+  for (const i of s)
+    n.push({ revision: i });
+  return n;
+}
+function U(e, t) {
+  return new Map(e.map((n) => [
+    n,
+    typeof n.key == "string" ? n.key : w(t(n))
+  ]));
+}
+function Be(e, t, n) {
+  for (const s of t)
+    if (s.type.name === e.type.name && n.get(s) === n.get(e))
+      return s;
+}
+function qe(e, t, n) {
+  let s, r = 0;
+  for (const o of t) {
+    if (o.type.name !== e.type.name)
+      continue;
+    const a = Ge(e, o, n);
+    a >= Le && a > r && (s = o, r = a);
+  }
+  return s;
+}
+function Ge(e, t, n) {
+  if (he(e) === "field")
+    return e.key === t.key ? 1 : 0;
+  const s = n.get(e), r = n.get(t), o = Math.max(s.length, r.length);
+  return o === 0 ? 1 : 1 - ge(s, r) / o;
+}
+function w(e) {
+  return Array.isArray(e) ? `[${e.map(w).join(",")}]` : y(e) ? `{${Object.keys(e).sort().map((n) => `${JSON.stringify(n)}:${w(e[n])}`).join(",")}}` : JSON.stringify(e) ?? "null";
+}
+function Ke(e, t) {
+  const n = [], s = /* @__PURE__ */ new Map();
+  function r(o) {
+    const a = P(o);
+    if (a.base && a.revision) {
+      const i = `${a.base.location.absolutePointer}|${a.revision.location.absolutePointer}`, c = s.get(i);
+      if (c) {
+        c.referencedBy.push(o);
+        return;
+      }
+      s.set(i, o);
+    }
+    if (n.push(...$e(o)), !(!a.base || !a.revision)) {
+      for (const i of ze(a.base.children, a.revision.children)) {
+        const c = { ...i, parent: o, referencedBy: [] };
+        i.base && i.revision && typeof i.base.key == "string" && i.base.key !== i.revision.key && n.push({
+          path: S(c),
+          node: c,
+          kind: "modified",
+          property: "key",
+          base: { location: i.base.location, value: i.base.key },
+          revision: { location: i.revision.location, value: i.revision.key }
+        }), r(c);
+      }
+      ve(a) && r({
+        base: a.base.resolved,
+        revision: a.revision.resolved,
+        parent: o,
+        referencedBy: []
+      });
+    }
+  }
+  return r({ base: e, revision: t, parent: null, referencedBy: [] }), n;
+}
+const Ue = ["request", "response"];
+function Ae(e) {
+  const t = ce(e.revision ? "revision" : "base", e, /* @__PURE__ */ new Set());
+  return Ue.filter((n) => t.includes(n));
+}
+function ce(e, t, n) {
+  if (n.has(t))
+    return [];
+  n.add(t);
+  const s = A(P(t)[e]) ?? A(t[e]);
+  return s ? [s] : [t.parent, ...t.referencedBy].flatMap((r) => r ? ce(e, r, n) : []);
+}
+function A(e) {
+  switch (e.type.name) {
+    case "RequestBody":
+    case "ParameterList":
+      return Y(e, "request");
+    case "Responses":
+      return Y(e, "response");
+    // "readOnly" data only comes from the API and "writeOnly" data only goes to it (OpenAPI,
+    // Schema Object), wherever the schema is used.
+    case "Schema":
+      return E(e, "readOnly") === !0 ? "response" : E(e, "writeOnly") === !0 ? "request" : void 0;
+    // AsyncAPI 3: `receive` means another application produces the message, so its payload is
+    // judged the way a request body is; `send` means this application produces it. An OpenAPI
+    // operation has no `action`, so it says nothing.
+    case "Operation":
+      return H(E(e, "action"));
+    // A reply answers the operation, so it travels back the other way.
+    case "OperationReply": {
+      const t = H(E(O(e, "Operation"), "action"));
+      return t && fe(t);
+    }
+    default:
+      return;
+  }
+}
+function Y(e, t) {
+  return O(e, "Components") ? void 0 : O(e, "CallbacksMap") ?? O(e, "WebhooksMap") ? fe(t) : t;
+}
+function H(e) {
+  if (e === "receive")
+    return "request";
+  if (e === "send")
+    return "response";
+}
+function fe(e) {
+  return e === "request" ? "response" : "request";
+}
+const Ye = /* @__PURE__ */ new Set(["enter", "leave", "skip"]);
+function le(e, t, n = []) {
+  return Object.entries(e).flatMap(([s, r]) => {
+    if (Ye.has(s) || s === "any" && n.length > 0)
+      throw new Error(`Diff rule '${t}' uses '${s}' where diff visitors do not have it.`);
+    return typeof r != "function" ? le(r, t, [...n, s]) : [{ typePath: s === "any" ? [] : [...n, s], visit: r }];
+  });
+}
+function He(e, t) {
+  let n = t;
+  for (let s = e.length - 1; s >= 0; s--) {
+    if (n === void 0 || D(n) !== e[s])
+      return !1;
+    s > 0 && (n = We(n.parent, [e[s - 1], e[s]]));
+  }
+  return !0;
+}
+function We(e, t) {
+  for (let n = e; n; n = n.parent)
+    if (t.includes(D(n)))
+      return n;
+}
+function Je(e, t, n) {
+  const s = t.flatMap(({ ruleId: r, impact: o, visitor: a }) => le(a, r).map((i) => ({ ruleId: r, impact: o, ...i })));
+  return e.map((r) => Xe(r, s, n));
+}
+function Xe(e, t, n) {
+  let s;
+  const r = () => s ??= Ae(e.node), o = Me(e).location, a = [];
+  for (const { ruleId: c, impact: d, typePath: l, visit: f } of t) {
+    if (!He(l, e.node))
+      continue;
+    f(e, { report: (p) => {
+      a.push({
+        ruleId: c,
+        impact: d,
+        message: p.message,
+        location: p.location ?? o
+      });
+    }, location: o, getDirections: r, specVersion: n });
+  }
+  const i = se(a.map((c) => c.impact));
+  return { ...e, verdicts: a, impact: i ?? be(e) };
+}
+async function pt(e) {
+  const { base: t, revision: n, config: s, externalRefResolver: r = new T(s.resolve) } = e, o = M(t.parsed), a = M(n.parsed), i = x(a);
+  if (x(o) !== i)
+    throw new Ee(`Cannot compare ${o} with ${a}.`);
+  const [c, d] = await Promise.all([
+    W(t, o, s, r),
+    W(n, a, s, r)
+  ]), l = Se(s.getDiffRulesForSpecVersion(i), s, a), f = Je(Ke(c.root, d.root), l, a);
+  return {
+    files: {
+      base: t.source.absoluteRef,
+      revision: n.source.absoluteRef
+    },
+    specVersions: {
+      base: o,
+      revision: a
+    },
+    infoVersions: { base: J(t), revision: J(n) },
+    summary: Qe(f),
+    bump: Ze(f),
+    changes: f,
+    // The base is not the author's to fix, so its problems only warn.
+    problems: [
+      ...c.problems.map((u) => ({ ...u, severity: "warn" })),
+      ...d.problems
+    ]
+  };
+}
+async function W(e, t, n, s) {
+  const r = n.getRulesForSpecVersion(x(t)), o = re(n.extendTypes(Oe(t), t), n), a = {
+    problems: [],
+    specVersion: t,
+    config: n,
+    visitorsData: {}
+  }, i = Te(r, n, "decorators", t);
+  let c = await k({
+    rootDocument: e,
+    rootType: o.Root,
+    externalRefResolver: s
+  });
+  return i.length > 0 && (I({
+    document: e,
+    rootType: o.Root,
+    normalizedVisitors: N(i, o),
+    resolvedRefMap: c,
+    ctx: a
+  }), c = await k({
+    rootDocument: e,
+    rootType: o.Root,
+    externalRefResolver: s
+  })), {
+    root: Fe({ document: e, types: o, resolvedRefMap: c, ctx: a }),
+    problems: a.problems.map((d) => n.addProblemToIgnore(d))
+  };
+}
+function J({ parsed: e }) {
+  const t = y(e) && y(e.info) ? e.info.version : void 0;
+  return typeof t == "string" ? t : void 0;
+}
+function Qe(e) {
+  const t = { major: 0, minor: 0, patch: 0 };
+  for (const n of e)
+    t[n.impact]++;
+  return t;
+}
+function Ze(e) {
+  return se(e.flatMap((t) => t.kind === "modified" && t.property === "version" && D(t.node) === "Info" ? [] : [t.impact]));
+}
+export {
+  yt as AbortFlowError,
+  mt as Arazzo1Types,
+  ht as Arazzo1_1Types,
+  gt as AsyncApi2Types,
+  vt as AsyncApi3Types,
+  T as BaseResolver,
+  bt as CONFIG_BUNDLER_VISITOR_ID,
+  Et as CONFIG_FILE_NAME,
+  St as ConfigTypes,
+  Ot as ConfigValidationError,
+  Tt as DEFAULT_CONFIG,
+  Rt as DEFAULT_PROJECT_PLUGIN_PATHS,
+  Ee as HandledError,
+  xt as IGNORE_BANNER,
+  kt as IGNORE_FILE,
+  dn as Location,
+  wt as Oas2Types,
+  Nt as Oas3Types,
+  It as Oas3_1Types,
+  Pt as Oas3_2Types,
+  Dt as OpenRpcTypes,
+  _t as Overlay1Types,
+  Ct as PLUGINS_COLLECTOR_VISITOR_ID,
+  yn as ResolveError,
+  mn as Source,
+  ct as StatsAsync2,
+  ft as StatsAsync3,
+  at as StatsOAS,
+  hn as YamlParseError,
+  jt as bundle,
+  Ft as bundleDocument,
+  Vt as bundleFromString,
+  it as capitalize,
+  Mt as clearPluginsCache,
+  V as createConfig,
+  $t as createConfigTypes,
+  xe as createEntityTypes,
+  Q as dequal,
+  M as detectSpec,
+  pt as diffDocuments,
+  Me as displaySide,
+  st as doesYamlFileExist,
+  gn as escapePointerFragment,
+  Lt as findConfig,
+  zt as formatProblems,
+  Bt as getAstNodeByPointer,
+  qt as getCodeframe,
+  vn as getDir,
+  Gt as getLineColLocation,
+  x as getMajorSpecVersion,
+  Kt as getPluginCacheVersion,
+  Ut as getTotals,
+  Oe as getTypes,
+  At as impactRank,
+  Yt as impacts,
+  bn as isAbsoluteUrl,
+  En as isBrowser,
+  X as isEmptyObject,
+  Sn as isGraphqlRef,
+  On as isMappingRef,
+  Ht as isNotEmptyArray,
+  rt as isNotEmptyObject,
+  y as isPlainObject,
+  Re as isRef,
+  Wt as isString,
+  Tn as isSupportedExtension,
+  Rn as isTruthy,
+  Jt as keysOf,
+  Xt as lint,
+  Qt as lintConfig,
+  te as lintDocument,
+  Ce as lintEntityFile,
+  lt as lintEntityWithScorecardLevel,
+  Zt as lintFromString,
+  je as lintSchema,
+  en as loadConfig,
+  tn as loadIgnoreConfig,
+  nn as logger,
+  oe as makeDocumentFromString,
+  sn as mapTypeToComponent,
+  rn as nameOf,
+  re as normalizeTypes,
+  N as normalizeVisitors,
+  xn as parsePointer,
+  kn as parseYaml,
+  ot as pause,
+  on as pluralize,
+  wn as readFileFromUrl,
+  an as regexFromString,
+  k as resolveDocument,
+  Nn as resolvePath,
+  cn as resolvePlugins,
+  fn as slash,
+  In as stringifyYaml,
+  D as typeOf,
+  Pn as unescapePointerFragment,
+  ln as validate,
+  I as walkDocument,
+  pn as xmlEscape
+};