oas 38.3.0 → 38.4.0

package/dist/chunk-4CWJNFV5.js

@@ -0,0 +1,709 @@
+import {
+  query
+} from "./chunk-QTPMJRIE.js";
+import {
+  Operation
+} from "./chunk-5ZBXVQYR.js";
+import {
+  decodePointer,
+  supportedMethods
+} from "./chunk-ANZIKNVX.js";
+import {
+  isOpenAPI31,
+  isRef
+} from "./chunk-XG4HGNCN.js";
+
+// src/lib/transformer/index.ts
+import jsonPointer from "jsonpointer";
+
+// src/lib/transformer/operation-selection.ts
+var OperationSelection = class {
+  selections = /* @__PURE__ */ new Map();
+  /** Whether any paths or webhooks have been selected. */
+  get hasSelections() {
+    return this.selections.size > 0;
+  }
+  /**
+   * Select every operation within a path or webhook.
+   *
+   * @param key Path or webhook key whose operations should be selected.
+   */
+  addAll(key) {
+    this.selections.set(this.normalize(key), "*");
+  }
+  /**
+   * Add an operation to the selection for a path or webhook. If every operation for the key is
+   * already selected, that selection remains unchanged.
+   *
+   * @param key Path or webhook key that contains the operation.
+   * @param method HTTP method of the operation to select.
+   */
+  addOperation(key, method) {
+    const normalizedKey = this.normalize(key);
+    const normalizedMethod = this.normalize(method);
+    const selection = this.selections.get(normalizedKey);
+    if (selection === "*") {
+      return;
+    }
+    if (selection instanceof Set) {
+      selection.add(normalizedMethod);
+      return;
+    }
+    this.selections.set(normalizedKey, /* @__PURE__ */ new Set([normalizedMethod]));
+  }
+  /**
+   * Clear every operation selection for a path or webhook.
+   *
+   * @param key Path or webhook key to clear.
+   */
+  clear(key) {
+    this.selections.delete(this.normalize(key));
+  }
+  /**
+   * Determine whether a path or webhook has any selected operations.
+   *
+   * @param key Path or webhook key to check.
+   */
+  has(key) {
+    return this.selections.has(this.normalize(key));
+  }
+  /**
+   * Determine whether every operation within a path or webhook is selected.
+   *
+   * @param key Path or webhook key to check.
+   */
+  matchesAll(key) {
+    return this.selections.get(this.normalize(key)) === "*";
+  }
+  /**
+   * Determine whether an operation is selected.
+   *
+   * @param key Path or webhook key that contains the operation.
+   * @param method HTTP method of the operation to check.
+   */
+  matches(key, method) {
+    const selection = this.selections.get(this.normalize(key));
+    return selection === "*" || Boolean(selection?.has(this.normalize(method)));
+  }
+  /** Normalize path, webhook, and method casing for comparisons. */
+  normalize(value) {
+    return value.toLowerCase();
+  }
+};
+
+// src/lib/transformer/index.ts
+var OpenAPITransformer = class {
+  definition;
+  mode;
+  /**
+   * A collection of `$ref` pointers that are used within our transformed API definition. This is
+   * used to ensure that all referenced schemas are retained in our resulting API definition. Not
+   * retaining them would result in an invalid OpenAPI definition.
+   */
+  $refs = /* @__PURE__ */ new Set();
+  /**
+   * A collection of OpenAPI tags that are used within the transformed API definition.
+   */
+  usedTags = /* @__PURE__ */ new Set();
+  /**
+   * A collection of OpenAPI paths and operations that are cross-referenced from any other paths
+   * and operations that we're retaining. This collection is used to ensure that those operations
+   * are retained in our resulting API definition. Not retaining them would result in an invalid
+   * OpenAPI definition.
+   */
+  retainPathMethods = /* @__PURE__ */ new Set();
+  /**
+   * A collection of OpenAPI webhook names and methods that are cross-referenced from any other
+   * schemas. This collection, like `retainPathMethods`, is used to ensure that those operations are
+   * retained in our resulting API definition. Not retaining them would result in an invalid
+   * OpenAPI definition.
+   */
+  retainWebhookMethods = /* @__PURE__ */ new Set();
+  /** An array of OpenAPI tags selected for the current transformation. */
+  tagSelection = [];
+  /** A collection of operation IDs selected for the current transformation. */
+  operationIdSelection = /* @__PURE__ */ new Set();
+  /** A collection of OpenAPI paths and operations selected for the current transformation. */
+  pathSelection = new OperationSelection();
+  /** A collection of OpenAPI webhooks selected for the current transformation. */
+  webhookSelection = new OperationSelection();
+  hasTagSelection = false;
+  hasOperationIdSelection = false;
+  hasPathSelection = false;
+  hasWebhookSelection = false;
+  /**
+   * @param definition OpenAPI definition to transform.
+   * @param options Transformation mode.
+   */
+  constructor(definition, options) {
+    this.definition = structuredClone(definition);
+    this.mode = options.mode;
+  }
+  /**
+   * Select an OpenAPI tag. Operations with this tag are retained when reducing and removed when
+   * pruning. Tag casing does not matter.
+   *
+   * @param tag Tag to select.
+   */
+  selectTag(tag) {
+    this.tagSelection.push(tag.toLowerCase());
+  }
+  /**
+   * Select an entire OpenAPI path and all operations that it contains. Selected paths are retained
+   * when reducing and removed when pruning. Path casing does not matter.
+   *
+   * @param path Path to select.
+   */
+  selectPath(path) {
+    this.pathSelection.addAll(path);
+  }
+  /**
+   * Select a single OpenAPI operation. Selected operations are retained when reducing and removed
+   * when pruning. Path and method casing does not matter.
+   *
+   * In reduce mode, selecting an operation after its entire path replaces the all-operation
+   * selection with that operation and any operations selected afterward. Prune mode keeps the
+   * entire path selected.
+   *
+   * @param path Path containing the operation.
+   * @param method HTTP method of the operation to select.
+   */
+  selectOperation(path, method) {
+    if (this.mode === "reduce" && this.pathSelection.matchesAll(path)) {
+      this.pathSelection.clear(path);
+    }
+    this.pathSelection.addOperation(path, method);
+  }
+  /**
+   * Select an OpenAPI operation by its operation ID. IDs are matched exactly and are generated
+   * from the operation path and method when one is not authored in the definition.
+   *
+   * @param operationId Operation ID to select.
+   */
+  selectOperationId(operationId) {
+    this.operationIdSelection.add(operationId);
+  }
+  /**
+   * Select an OpenAPI webhook or one of its operations. Selected webhooks are retained when
+   * reducing and removed when pruning. Webhook and method casing does not matter.
+   *
+   * @param webhookName Webhook to select.
+   * @param method Optional HTTP method of an individual webhook operation to select.
+   */
+  selectWebhook(webhookName, method) {
+    if (!method) {
+      this.webhookSelection.addAll(webhookName);
+      return;
+    }
+    if (this.mode === "reduce" && this.webhookSelection.matchesAll(webhookName)) {
+      this.webhookSelection.clear(webhookName);
+    }
+    this.webhookSelection.addOperation(webhookName, method);
+  }
+  /** Transform the OpenAPI definition according to the configured mode and selections. */
+  transform() {
+    if (!this.definition.openapi) {
+      throw new Error("Sorry, only OpenAPI definitions are supported.");
+    }
+    this.hasTagSelection = Boolean(this.tagSelection.length);
+    this.hasOperationIdSelection = this.operationIdSelection.size > 0;
+    this.hasPathSelection = this.pathSelection.hasSelections;
+    this.hasWebhookSelection = this.webhookSelection.hasSelections;
+    if ("security" in this.definition) {
+      Object.values(this.definition.security || {}).forEach((sec) => {
+        Object.keys(sec).forEach((scheme) => {
+          this.$refs.add(`#/components/securitySchemes/${scheme}`);
+        });
+      });
+    }
+    this.walkPaths();
+    this.walkWebhooks();
+    this.$refs.forEach(($ref) => {
+      this.accumulateUsedRefs(this.definition, this.$refs, $ref);
+    });
+    this.$refs.forEach((ref) => {
+      const usedPathRef = this.parsePathRef(ref);
+      if (usedPathRef) {
+        this.retainPathMethods.add(`${usedPathRef.path.toLowerCase()}|${usedPathRef.method.toLowerCase()}`);
+      }
+      const usedWebhookRef = this.parseWebhookRef(ref);
+      if (usedWebhookRef) {
+        this.retainWebhookMethods.add(`${usedWebhookRef.name.toLowerCase()}|${usedWebhookRef.method.toLowerCase()}`);
+      }
+    });
+    this.transformPaths();
+    this.transformWebhooks();
+    const hasPaths = Boolean(this.definition.paths && Object.keys(this.definition.paths).length);
+    const hasWebhooks = Boolean(
+      "webhooks" in this.definition && this.definition.webhooks && Object.keys(this.definition.webhooks).length
+    );
+    if (this.mode === "reduce" && !hasPaths && !hasWebhooks) {
+      throw new Error(
+        "All paths and webhooks in the API definition were removed. Did you supply the right path, operation, or webhook to reduce by?"
+      );
+    }
+    if ("components" in this.definition) {
+      Object.keys(this.definition.components || {}).forEach((componentType) => {
+        Object.keys(this.definition.components?.[componentType] || {}).forEach((component) => {
+          const refIsUsed = this.$refs.has(`#/components/${componentType}/${component}`) || Array.from(this.$refs).some((ref) => {
+            return ref.startsWith(`#/components/${componentType}/${component}/`);
+          });
+          if (!refIsUsed) {
+            delete this.definition.components?.[componentType]?.[component];
+          }
+        });
+        if (!Object.keys(this.definition.components?.[componentType] || {}).length) {
+          delete this.definition.components?.[componentType];
+        }
+      });
+      if (!Object.keys(this.definition.components || {}).length) {
+        delete this.definition.components;
+      }
+    }
+    if ("tags" in this.definition) {
+      this.definition.tags = (this.definition.tags ?? []).filter((tag) => {
+        return Boolean(tag) && this.usedTags.has(tag.name);
+      });
+      if (!this.definition.tags?.length) {
+        delete this.definition.tags;
+      }
+    }
+    return this.definition;
+  }
+  /**
+   * Recursively process a `$ref` pointer and accumulate any other `$ref` pointers that it or its
+   * children use. This handles circular references by skipping `$ref` pointers we have already seen.
+   * Additionally when a `$ref` points to `#/paths` we record the used path + method so we can
+   * retain cross-operation references within the transformed definition.
+   *
+   * @param schema JSON Schema object to look for and accumulate any `$ref` pointers that it may have.
+   * @param $refs Known set of `$ref` pointers.
+   * @param $ref `$ref` pointer to fetch a schema from out of the supplied schema.
+   */
+  accumulateUsedRefs(schema, $refs, $ref) {
+    const pathRef = this.parsePathRef($ref);
+    if (pathRef) {
+      this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
+    }
+    const webhookRef = this.parseWebhookRef($ref);
+    if (webhookRef) {
+      this.retainWebhookMethods.add(`${webhookRef.name.toLowerCase()}|${webhookRef.method.toLowerCase()}`);
+    }
+    let $refSchema;
+    if (typeof $ref === "string") $refSchema = jsonPointer.get(schema, $ref.substring(1));
+    if ($refSchema === void 0) {
+      return;
+    }
+    this.queryForRefPointers($refSchema).forEach(({ value: currRef }) => {
+      const foundRef = this.toRefString(currRef);
+      if (!foundRef) {
+        return;
+      }
+      if ($refs.has(foundRef)) {
+        return;
+      }
+      $refs.add(foundRef);
+      this.accumulateUsedRefs(schema, $refs, foundRef);
+    });
+  }
+  /**
+   * Query a JSON Schema object for any `$ref` pointers using JSONPath and return any pointers that
+   * exist.
+   *
+   * @see {@link https://datatracker.ietf.org/doc/html/rfc9535}
+   * @param schema JSON Schema object to look for any `$ref` pointers within it.
+   */
+  queryForRefPointers(schema) {
+    return query(["$..['$ref']"], schema);
+  }
+  /**
+   * Normalize a value from a `jsonpath-plus` `$ref` query to a `$ref` pointer because JSONPath
+   * queries may return the property value or the parent.
+   *
+   */
+  toRefString(value) {
+    if (typeof value === "string") {
+      return value;
+    } else if (value && typeof value === "object" && "$ref" in value && typeof value.$ref === "string") {
+      return value.$ref;
+    }
+    return null;
+  }
+  /**
+   * If the given `$ref` points into a path (e.g. `#/paths/~1anything/post/...`), return the path
+   * and method so the transformer can retain cross-operation references.
+   *
+   */
+  parsePathRef($ref) {
+    if (typeof $ref !== "string" || !$ref.startsWith("#/paths/")) {
+      return null;
+    }
+    const match = $ref.match(/^#\/paths\/([^/]+)\/([^/]+)(?:\/|$)/);
+    if (match) {
+      const pathSegment = match[1];
+      const method = match[2];
+      if (pathSegment && method) {
+        return { path: decodePointer(pathSegment), method };
+      }
+    }
+    return null;
+  }
+  /**
+   * If the given `$ref` points into webhooks (e.g. `#/webhooks/newBooking/post/...`), return the
+   * webhook name and method so the transformer can retain cross-referenced webhook operations.
+   *
+   */
+  parseWebhookRef($ref) {
+    if (typeof $ref !== "string" || !$ref.startsWith("#/webhooks/")) {
+      return null;
+    }
+    const match = $ref.match(/^#\/webhooks\/([^/]+)\/([^/]+)(?:\/|$)/);
+    if (match) {
+      const webhookName = match[1];
+      const method = match[2];
+      if (webhookName && method) {
+        return { name: decodePointer(webhookName), method };
+      }
+    }
+    return null;
+  }
+  /** Determine whether a path or webhook is excluded in the current transformation mode. */
+  isContainerExcluded(selection, key) {
+    if (this.mode === "prune") {
+      return selection.matchesAll(key);
+    }
+    return !selection.has(key);
+  }
+  /**
+   * Determine whether an operation passes the configured filters before cross-operation references
+   * are considered.
+   */
+  shouldRetainOperation(selection, key, method, operation) {
+    if (this.mode === "reduce") {
+      if (selection.hasSelections && !selection.matches(key, method)) return false;
+      if (this.hasOperationIdSelection && !this.operationIdSelection.has(Operation.getOperationId(key, method, operation))) {
+        return false;
+      }
+      if (this.hasTagSelection && !(operation.tags || []).some((tag) => this.tagSelection.includes(tag.toLowerCase()))) {
+        return false;
+      }
+    } else {
+      if (selection.hasSelections && selection.matches(key, method)) return false;
+      if (this.hasOperationIdSelection && this.operationIdSelection.has(Operation.getOperationId(key, method, operation))) {
+        return false;
+      }
+      if (this.hasTagSelection && (operation.tags || []).some((tag) => this.tagSelection.includes(tag.toLowerCase()))) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /** Determine whether a path item contains at least one HTTP operation. */
+  hasOperations(pathItem) {
+    return Boolean(pathItem && supportedMethods.some((method) => method in pathItem));
+  }
+  /**
+   * Accumulate any `$ref` pointers that are used by common Path Item parameters.
+   *
+   * @param parameters Common Path Item parameters to inspect for `$ref` pointers.
+   */
+  accumulateParameterRefs(parameters) {
+    if (!parameters) {
+      return;
+    }
+    this.queryForRefPointers(parameters).forEach(({ value: ref }) => {
+      const refStr = this.toRefString(ref);
+      if (!refStr) {
+        return;
+      }
+      this.$refs.add(refStr);
+      this.accumulateUsedRefs(this.definition, this.$refs, refStr);
+    });
+  }
+  /**
+   * Walk through the `paths` in our OpenAPI definition and determine which operations we want to
+   * retain. Accumulate any `$ref` pointers that they use so their referenced schemas can also be
+   * retained in our resulting API definition.
+   *
+   */
+  walkPaths() {
+    if (!("paths" in this.definition) || !this.definition.paths) {
+      return;
+    }
+    Object.keys(this.definition.paths).forEach((path) => {
+      if (this.mode === "reduce" && this.hasWebhookSelection && !this.hasPathSelection) {
+        return;
+      } else if (this.hasPathSelection && this.isContainerExcluded(this.pathSelection, path)) {
+        return;
+      }
+      const pathItem = this.definition.paths?.[path];
+      if (isRef(pathItem)) {
+        this.$refs.add(pathItem.$ref);
+        this.accumulateUsedRefs(this.definition, this.$refs, pathItem.$ref);
+      }
+      if (!this.hasOperations(pathItem)) {
+        this.accumulateParameterRefs(pathItem?.parameters);
+      }
+      Object.keys(pathItem || {}).forEach((method) => {
+        if (method === "parameters" || !supportedMethods.includes(method.toLowerCase())) {
+          return;
+        }
+        const operation = this.definition.paths?.[path]?.[method];
+        if (!operation) {
+          throw new Error(`Operation \`${method} ${path}\` not found`);
+        }
+        if (!this.shouldRetainOperation(this.pathSelection, path, method, operation)) {
+          return;
+        }
+        (operation.tags || []).forEach((tag) => {
+          this.usedTags.add(tag);
+        });
+        this.accumulateParameterRefs(pathItem?.parameters);
+        this.queryForRefPointers(operation).forEach(({ value: ref }) => {
+          const refStr = this.toRefString(ref);
+          if (!refStr) {
+            return;
+          }
+          this.$refs.add(refStr);
+          const pathRef = this.parsePathRef(refStr);
+          if (pathRef) {
+            this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
+          }
+          this.accumulateUsedRefs(this.definition, this.$refs, refStr);
+        });
+        Object.values(operation.security || {}).forEach((sec) => {
+          Object.keys(sec).forEach((scheme) => {
+            this.$refs.add(`#/components/securitySchemes/${scheme}`);
+          });
+        });
+      });
+    });
+  }
+  /**
+   * Walk through the `webhooks` in our OpenAPI definition and determine which operations we want
+   * to retain. Accumulate any `$ref` pointers that they use so their referenced schemas can also be
+   * retained in our resulting API definition.
+   *
+   */
+  walkWebhooks() {
+    if (!isOpenAPI31(this.definition)) {
+      return;
+    } else if (!("webhooks" in this.definition) || !this.definition.webhooks) {
+      return;
+    }
+    const definition = this.definition;
+    Object.keys(definition.webhooks || {}).forEach((webhookName) => {
+      if (this.hasWebhookSelection && this.isContainerExcluded(this.webhookSelection, webhookName)) {
+        return;
+      }
+      const webhook = definition.webhooks?.[webhookName];
+      if (!webhook || typeof webhook !== "object") {
+        return;
+      }
+      if (typeof webhook.$ref === "string") {
+        this.$refs.add(webhook.$ref);
+        this.accumulateUsedRefs(definition, this.$refs, webhook.$ref);
+      }
+      if (!this.hasOperations(webhook)) {
+        this.accumulateParameterRefs(webhook.parameters);
+      }
+      Object.keys(webhook).forEach((method) => {
+        if (method === "parameters" || !supportedMethods.includes(method.toLowerCase())) {
+          return;
+        }
+        const operation = webhook[method];
+        if (!operation) {
+          throw new Error(`Webhook operation \`${method} ${webhookName}\` not found`);
+        }
+        if (!this.shouldRetainOperation(this.webhookSelection, webhookName, method, operation)) {
+          return;
+        }
+        (operation.tags || []).forEach((tag) => {
+          this.usedTags.add(tag);
+        });
+        this.accumulateParameterRefs(webhook.parameters);
+        this.queryForRefPointers(operation).forEach(({ value: ref }) => {
+          const refStr = this.toRefString(ref);
+          if (!refStr) {
+            return;
+          }
+          this.$refs.add(refStr);
+          const pathRef = this.parsePathRef(refStr);
+          if (pathRef) {
+            this.retainPathMethods.add(`${pathRef.path.toLowerCase()}|${pathRef.method.toLowerCase()}`);
+          }
+          const webhookRef = this.parseWebhookRef(refStr);
+          if (webhookRef) {
+            this.retainWebhookMethods.add(`${webhookRef.name.toLowerCase()}|${webhookRef.method.toLowerCase()}`);
+          }
+          this.accumulateUsedRefs(definition, this.$refs, refStr);
+        });
+        Object.values(operation.security || {}).forEach((sec) => {
+          Object.keys(sec).forEach((scheme) => {
+            this.$refs.add(`#/components/securitySchemes/${scheme}`);
+          });
+        });
+      });
+    });
+  }
+  /**
+   * Transform our `paths` object according to the paths and operations that we've selected.
+   */
+  transformPaths() {
+    if (!("paths" in this.definition) || !this.definition.paths) {
+      return;
+    }
+    Object.keys(this.definition.paths).forEach((path) => {
+      const pathLC = path.toLowerCase();
+      const excludePathItem = this.hasPathSelection && this.isContainerExcluded(this.pathSelection, path) || this.mode === "reduce" && this.hasWebhookSelection && !this.hasPathSelection;
+      if (this.mode === "prune" && excludePathItem) {
+        if (Array.from(this.retainPathMethods).some((key) => key.startsWith(`${pathLC}|`))) {
+          throw new Error(`Cannot remove path \`${path}\` because one of its operations is referenced.`);
+        }
+        delete this.definition.paths?.[path];
+        return;
+      }
+      const pathItem = this.definition.paths?.[path];
+      if (isRef(pathItem)) {
+        if (excludePathItem) {
+          const retainedByRef = Array.from(this.retainPathMethods).some((key) => key.startsWith(`${pathLC}|`));
+          if (!retainedByRef) {
+            delete this.definition.paths?.[path];
+          }
+        }
+        return;
+      }
+      let removedOperation = false;
+      Object.keys(pathItem || {}).forEach((method) => {
+        const methodLC = method.toLowerCase();
+        if (method === "parameters" || !supportedMethods.includes(methodLC)) {
+          return;
+        }
+        const retainedByRef = this.retainPathMethods.has(`${pathLC}|${methodLC}`) || Array.from(this.$refs).some((ref) => {
+          const pathRef = this.parsePathRef(ref);
+          return pathRef?.path.toLowerCase() === pathLC && pathRef?.method.toLowerCase() === methodLC;
+        });
+        const operation = this.definition.paths?.[path]?.[method];
+        if (!operation) {
+          throw new Error(`Operation \`${method} ${path}\` not found`);
+        }
+        if (excludePathItem || !this.shouldRetainOperation(this.pathSelection, path, method, operation)) {
+          if (this.mode === "prune" && retainedByRef) {
+            throw new Error(`Cannot remove operation \`${method.toUpperCase()} ${path}\` because it is referenced.`);
+          }
+          if (!retainedByRef) {
+            delete this.definition.paths?.[path]?.[method];
+            removedOperation = true;
+            return;
+          }
+        }
+        this.accumulateParameterRefs(pathItem?.parameters);
+        if ("tags" in operation) {
+          operation.tags?.forEach((tag) => {
+            this.usedTags.add(tag);
+          });
+        }
+        if ("security" in operation) {
+          Object.values(operation.security || {}).forEach((sec) => {
+            Object.keys(sec).forEach((scheme) => {
+              this.$refs.add(`#/components/securitySchemes/${scheme}`);
+            });
+          });
+        }
+      });
+      if ((removedOperation || this.mode === "reduce" && excludePathItem) && !this.hasOperations(pathItem) || this.mode === "reduce" && !Object.keys(this.definition.paths?.[path] || {}).length) {
+        delete this.definition.paths?.[path];
+      }
+    });
+    if (!Object.keys(this.definition.paths || {}).length) {
+      if (this.mode === "reduce" && !(this.definition.webhooks && Object.keys(this.definition.webhooks).length)) {
+        throw new Error(
+          "All paths in the API definition were removed. Did you supply the right path name to reduce by?"
+        );
+      }
+      if (this.definition.webhooks && Object.keys(this.definition.webhooks).length) {
+        delete this.definition.paths;
+      }
+    }
+  }
+  /**
+   * Transform our `webhooks` object according to the webhooks and operations that we've selected.
+   */
+  transformWebhooks() {
+    if (!isOpenAPI31(this.definition)) {
+      return;
+    } else if (!("webhooks" in this.definition) || !this.definition.webhooks) {
+      return;
+    }
+    const definition = this.definition;
+    Object.keys(definition.webhooks || {}).forEach((webhookName) => {
+      const nameLC = webhookName.toLowerCase();
+      const excludeWebhook = this.hasWebhookSelection && this.isContainerExcluded(this.webhookSelection, webhookName);
+      if (this.mode === "prune" && excludeWebhook) {
+        const retainedByRef = Array.from(this.retainWebhookMethods).some((key) => key.startsWith(`${nameLC}|`));
+        if (retainedByRef) {
+          throw new Error(`Cannot remove webhook \`${webhookName}\` because one of its operations is referenced.`);
+        }
+        delete definition.webhooks?.[webhookName];
+        return;
+      }
+      const webhook = definition.webhooks?.[webhookName];
+      if (!webhook || typeof webhook !== "object") {
+        return;
+      }
+      if (isRef(webhook)) {
+        if (excludeWebhook) {
+          const retainedByRef = Array.from(this.retainWebhookMethods).some((key) => key.startsWith(`${nameLC}|`));
+          if (!retainedByRef) {
+            delete definition.webhooks?.[webhookName];
+          }
+        }
+        return;
+      }
+      let removedOperation = false;
+      Object.keys(webhook).forEach((method) => {
+        const methodLC = method.toLowerCase();
+        if (method === "parameters" || !supportedMethods.includes(methodLC)) {
+          return;
+        }
+        const operation = webhook[method];
+        if (!operation) {
+          throw new Error(`Webhook operation \`${method} ${webhookName}\` not found`);
+        }
+        const retainedByRef = this.retainWebhookMethods.has(`${nameLC}|${methodLC}`);
+        if (excludeWebhook || !this.shouldRetainOperation(this.webhookSelection, webhookName, method, operation)) {
+          if (this.mode === "prune" && retainedByRef) {
+            throw new Error(
+              `Cannot remove operation \`${method.toUpperCase()} ${webhookName}\` because it is referenced.`
+            );
+          }
+          if (!retainedByRef) {
+            delete webhook[method];
+            removedOperation = true;
+            return;
+          }
+        }
+        this.accumulateParameterRefs(webhook.parameters);
+        (operation.tags || []).forEach((tag) => {
+          this.usedTags.add(tag);
+        });
+        Object.values(operation.security || {}).forEach((sec) => {
+          Object.keys(sec).forEach((scheme) => {
+            this.$refs.add(`#/components/securitySchemes/${scheme}`);
+          });
+        });
+      });
+      if ((removedOperation || this.mode === "reduce" && excludeWebhook) && !this.hasOperations(webhook) || this.mode === "reduce" && !Object.keys(definition.webhooks?.[webhookName] || {}).length) {
+        delete definition.webhooks?.[webhookName];
+      }
+    });
+    if (definition.webhooks && !Object.keys(definition.webhooks).length) {
+      delete definition.webhooks;
+    }
+  }
+};
+
+export {
+  OpenAPITransformer
+};
+//# sourceMappingURL=chunk-4CWJNFV5.js.map