@visulima/jsdoc-open-api 2.0.91 → 2.0.93

package/dist/chunk-WUINTXB7.mjs

@@ -0,0 +1,1205 @@
+import { parse } from 'comment-parser';
+import mergeWith from 'lodash.mergewith';
+import { readFileSync } from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+import { createRequire } from 'module';
+import SwaggerParser from '@apidevtools/swagger-parser';
+
+// src/jsdoc/comments-to-open-api.ts
+
+// src/util/customizer.ts
+var customizer = (objectValue, sourceValue) => {
+  if (Array.isArray(objectValue)) {
+    return [...objectValue, ...sourceValue];
+  }
+  return void 0;
+};
+var customizer_default = customizer;
+
+// src/jsdoc/comments-to-open-api.ts
+var fixSecurityObject = (thing) => {
+  if (thing.security) {
+    thing.security = Object.keys(thing.security).map((s) => {
+      return {
+        [s]: thing.security[s]
+      };
+    });
+  }
+};
+var primitiveTypes = /* @__PURE__ */ new Set(["array", "boolean", "integer", "number", "object", "string"]);
+var formatMap = {
+  binary: "string",
+  byte: "string",
+  date: "string",
+  "date-time": "string",
+  double: "number",
+  float: "number",
+  int32: "integer",
+  int64: "integer",
+  password: "string"
+};
+var parseDescription = (tag) => {
+  const rawType = tag.type;
+  const isArray = rawType.endsWith("[]");
+  const parsedType = rawType.replace(/\[]$/, "");
+  const isPrimitive = primitiveTypes.has(parsedType);
+  const isFormat = Object.keys(formatMap).includes(parsedType);
+  let defaultValue;
+  if (tag.default) {
+    switch (parsedType) {
+      case "double":
+      case "float":
+      case "number": {
+        defaultValue = Number.parseFloat(tag.default);
+        break;
+      }
+      case "int32":
+      case "int64":
+      case "integer": {
+        defaultValue = Number.parseInt(tag.default, 10);
+        break;
+      }
+      default: {
+        defaultValue = tag.default;
+        break;
+      }
+    }
+  }
+  let rootType;
+  if (isPrimitive) {
+    rootType = { default: defaultValue, type: parsedType };
+  } else if (isFormat) {
+    rootType = {
+      default: defaultValue,
+      format: parsedType,
+      type: formatMap[parsedType]
+    };
+  } else {
+    rootType = { $ref: `#/components/schemas/${parsedType}` };
+  }
+  let schema = isArray ? {
+    items: {
+      ...rootType
+    },
+    type: "array"
+  } : {
+    ...rootType
+  };
+  if (parsedType === "") {
+    schema = void 0;
+  }
+  let description = tag.description.trim().replace(/^- /u, "");
+  if (description === "") {
+    description = void 0;
+  }
+  return {
+    description,
+    name: tag.name,
+    rawType,
+    required: !tag.optional,
+    schema
+  };
+};
+var tagsToObjects = (tags, verbose) => tags.map((tag) => {
+  const parsedResponse = parseDescription(tag);
+  let nameAndDescription = "";
+  if (parsedResponse.name) {
+    nameAndDescription += parsedResponse.name;
+  }
+  if (parsedResponse.description) {
+    nameAndDescription += ` ${parsedResponse.description.trim()}`;
+  }
+  switch (tag.tag) {
+    case "bodyComponent": {
+      return {
+        requestBody: {
+          $ref: `#/components/requestBodies/${parsedResponse.rawType}`
+        }
+      };
+    }
+    case "bodyContent": {
+      return {
+        requestBody: {
+          content: {
+            [parsedResponse.name.replace(String.raw`*\/*`, "*/*")]: {
+              schema: parsedResponse.schema
+            }
+          }
+        }
+      };
+    }
+    case "bodyDescription": {
+      return { requestBody: { description: nameAndDescription } };
+    }
+    case "bodyExample": {
+      const [contentType, example] = parsedResponse.name.split(".");
+      return {
+        requestBody: {
+          content: {
+            [contentType]: {
+              examples: {
+                [example]: {
+                  $ref: `#/components/examples/${parsedResponse.rawType}`
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "bodyRequired": {
+      return { requestBody: { required: true } };
+    }
+    case "callback": {
+      return {
+        callbacks: {
+          [parsedResponse.name]: {
+            $ref: `#/components/callbacks/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "cookieParam":
+    case "headerParam":
+    case "pathParam":
+    case "queryParam": {
+      return {
+        parameters: [
+          {
+            description: parsedResponse.description,
+            in: tag.tag.replace(/Param$/u, ""),
+            name: parsedResponse.name,
+            required: parsedResponse.required,
+            schema: parsedResponse.schema
+          }
+        ]
+      };
+    }
+    case "deprecated": {
+      return { deprecated: true };
+    }
+    case "description":
+    case "operationId":
+    case "summary": {
+      return { [tag.tag]: nameAndDescription };
+    }
+    case "externalDocs": {
+      return {
+        externalDocs: {
+          description: parsedResponse.description,
+          url: parsedResponse.name
+        }
+      };
+    }
+    case "paramComponent": {
+      return {
+        parameters: [{ $ref: `#/components/parameters/${parsedResponse.rawType}` }]
+      };
+    }
+    case "response": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            description: parsedResponse.description
+          }
+        }
+      };
+    }
+    case "responseComponent": {
+      return {
+        responses: {
+          [parsedResponse.name]: {
+            $ref: `#/components/responses/${parsedResponse.rawType}`
+          }
+        }
+      };
+    }
+    case "responseContent": {
+      const [status, contentType] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseExample": {
+      const [status, contentType, example] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            content: {
+              [contentType]: {
+                examples: {
+                  [example]: {
+                    $ref: `#/components/examples/${parsedResponse.rawType}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeader": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                description: parsedResponse.description,
+                schema: parsedResponse.schema
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseHeaderComponent": {
+      const [status, header] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            headers: {
+              [header]: {
+                $ref: `#/components/headers/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "responseLink": {
+      const [status, link] = parsedResponse.name.split(".");
+      return {
+        responses: {
+          [status]: {
+            links: {
+              [link]: {
+                $ref: `#/components/links/${parsedResponse.rawType}`
+              }
+            }
+          }
+        }
+      };
+    }
+    case "security": {
+      const [security, scopeItem] = parsedResponse.name.split(".");
+      let scope = [];
+      if (scopeItem) {
+        scope = [scopeItem];
+      }
+      return {
+        security: { [security]: scope }
+      };
+    }
+    case "server": {
+      return {
+        servers: [
+          {
+            description: parsedResponse.description,
+            url: parsedResponse.name
+          }
+        ]
+      };
+    }
+    case "tag": {
+      return { tags: [nameAndDescription] };
+    }
+    default: {
+      return {};
+    }
+  }
+});
+var commentsToOpenApi = (fileContents, verbose) => {
+  const openAPIRegex = /^(GET|PUT|POST|DELETE|OPTIONS|HEAD|PATCH|TRACE) \/.*$/;
+  const jsDocumentComments = parse(fileContents, { spacing: "preserve" });
+  return jsDocumentComments.filter((comment) => openAPIRegex.test(comment.description.trim())).map((comment) => {
+    const loc = comment.tags.length + 1;
+    const result = mergeWith({}, ...tagsToObjects(comment.tags), customizer_default);
+    fixSecurityObject(result);
+    const [method, path2] = comment.description.split(" ");
+    const pathsObject = {
+      [path2.trim()]: {
+        [method.toLowerCase().trim()]: {
+          ...result
+        }
+      }
+    };
+    const spec = JSON.parse(JSON.stringify({ paths: pathsObject }));
+    return {
+      loc,
+      spec
+    };
+  });
+};
+var comments_to_open_api_default = commentsToOpenApi;
+
+// src/util/yaml-loc.ts
+var yamlLoc = (string) => {
+  const split = string.split(/\r\n|\r|\n/u);
+  const filtered = split.filter((line) => {
+    if (/^\s*(#\s*(?:\S.*)?)?$/u.test(line)) {
+      return false;
+    }
+    return line.trim().length > 0;
+  });
+  return filtered.length;
+};
+var yaml_loc_default = yamlLoc;
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["components", "externalDocs", "info", "openapi", "paths", "security", "servers", "tags"]);
+var ParseError = class extends Error {
+  filePath;
+};
+var parseFile = (file, commentsToOpenApi3, verbose) => {
+  const fileContent = readFileSync(file, { encoding: "utf8" });
+  const extension = path.extname(file);
+  if (extension === ".yaml" || extension === ".yml") {
+    const spec = yaml.parse(fileContent);
+    const invalidKeys = Object.keys(spec).filter((key) => !ALLOWED_KEYS.has(key));
+    if (invalidKeys.length > 0) {
+      const error = new ParseError(`Unexpected keys: ${invalidKeys.join(", ")}`);
+      error.filePath = file;
+      throw error;
+    }
+    if (Object.keys(spec).some((key) => ALLOWED_KEYS.has(key))) {
+      const loc = yaml_loc_default(fileContent);
+      return [{ loc, spec }];
+    }
+    return [];
+  }
+  try {
+    return commentsToOpenApi3(fileContent, verbose);
+  } catch (error) {
+    error.filePath = file;
+    throw error;
+  }
+};
+var parse_file_default = parseFile;
+
+// src/util/object-merge.ts
+var objectMerge = (a, b) => {
+  Object.keys(b).forEach((key) => {
+    if (a[key] === void 0) {
+      a[key] = {
+        ...b[key]
+      };
+    } else {
+      Object.keys(b[key]).forEach((subKey) => {
+        a[key][subKey] = {
+          ...a[key][subKey],
+          ...b[key][subKey]
+        };
+      });
+    }
+  });
+};
+var object_merge_default = objectMerge;
+
+// src/spec-builder.ts
+var SpecBuilder = class {
+  components;
+  externalDocs;
+  info;
+  openapi;
+  paths;
+  security;
+  servers;
+  tags;
+  constructor(baseDefinition) {
+    this.openapi = baseDefinition.openapi;
+    this.info = baseDefinition.info;
+    this.paths = baseDefinition.paths ?? {};
+    if (baseDefinition.servers) {
+      this.servers = baseDefinition.servers;
+    }
+    if (baseDefinition.components) {
+      this.components = baseDefinition.components;
+    }
+    if (baseDefinition.security) {
+      this.security = baseDefinition.security;
+    }
+    if (baseDefinition.tags) {
+      this.tags = baseDefinition.tags;
+    }
+    if (baseDefinition.externalDocs) {
+      this.externalDocs = baseDefinition.externalDocs;
+    }
+  }
+  addData(parsedFile) {
+    parsedFile.forEach((file) => {
+      const { components, paths, ...rest } = file;
+      object_merge_default(this, {
+        components: components ?? {},
+        paths: paths ?? {}
+      });
+      Object.entries(rest).forEach(([key, value]) => {
+        this[key] = value;
+      });
+    });
+  }
+};
+var spec_builder_default = SpecBuilder;
+var mergeDeep = (first, second) => mergeWith({}, first, second, (a, b) => b === null ? a : void 0);
+var hasEmptyProperty = (object) => Object.keys(object).map((key) => object[key]).every((keyObject) => typeof keyObject === "object" && Object.keys(keyObject).every((key) => !(key in keyObject)));
+var isTagPresentInTags = (tag, tags) => tags.some((targetTag) => tag.name === targetTag.name);
+var getSwaggerVersionFromSpec = (tag) => {
+  switch (tag.tag) {
+    case "asyncapi": {
+      return "v4";
+    }
+    case "openapi": {
+      return "v3";
+    }
+    case "swagger": {
+      return "v2";
+    }
+    default: {
+      return "v2";
+    }
+  }
+};
+
+// src/swagger-jsdoc/organize-swagger-object.ts
+var organizeSwaggerObject = (swaggerObject, annotation, property) => {
+  if (property === "x-webhooks") {
+    swaggerObject[property] = annotation[property];
+  }
+  if (property.startsWith("x-")) {
+    return;
+  }
+  const commonProperties = [
+    "components",
+    "consumes",
+    "produces",
+    "paths",
+    "schemas",
+    "securityDefinitions",
+    "responses",
+    "parameters",
+    "definitions",
+    "channels"
+  ];
+  if (commonProperties.includes(property)) {
+    Object.keys(annotation[property]).forEach((definition) => {
+      swaggerObject[property][definition] = mergeDeep(swaggerObject[property][definition], annotation[property][definition]);
+    });
+  } else if (property === "tags") {
+    const { tags } = annotation;
+    if (Array.isArray(tags)) {
+      tags.forEach((tag) => {
+        if (!isTagPresentInTags(tag, swaggerObject.tags)) {
+          swaggerObject.tags.push(tag);
+        }
+      });
+    } else if (!isTagPresentInTags(tags, swaggerObject.tags)) {
+      swaggerObject.tags.push(tags);
+    }
+  } else if (property === "security") {
+    const { security } = annotation;
+    swaggerObject.security = security;
+  } else if (property.startsWith("/")) {
+    swaggerObject.paths[property] = mergeDeep(swaggerObject.paths[property], annotation[property]);
+  }
+};
+var organize_swagger_object_default = organizeSwaggerObject;
+
+// src/swagger-jsdoc/comments-to-open-api.ts
+var specificationTemplate = {
+  v2: ["paths", "definitions", "responses", "parameters", "securityDefinitions"],
+  v3: ["paths", "definitions", "responses", "parameters", "securityDefinitions", "components"],
+  v4: ["components", "channels"]
+};
+var tagsToObjects2 = (specs, verbose) => specs.map((spec) => {
+  if ((spec.tag === "openapi" || spec.tag === "swagger" || spec.tag === "asyncapi") && spec.description !== "") {
+    const parsed = yaml.parseDocument(spec.description);
+    if (parsed.errors.length > 0) {
+      parsed.errors.map((error) => {
+        const newError = error;
+        newError.annotation = spec.description;
+        return newError;
+      });
+      let errorString = "Error parsing YAML in @openapi spec:";
+      errorString += verbose ? parsed.errors.map(
+        (error) => `${error.toString()}
+Imbedded within:
+\`\`\`
+  ${error.annotation?.replaceAll("\n", "\n  ")}
+\`\`\``
+      ).join("\n") : parsed.errors.map((error) => error.toString()).join("\n");
+      throw new Error(errorString);
+    }
+    const parsedDocument = parsed.toJSON();
+    const specification = {
+      tags: []
+    };
+    specificationTemplate[getSwaggerVersionFromSpec(spec)].forEach((property) => {
+      specification[property] = specification[property] || {};
+    });
+    Object.keys(parsedDocument).forEach((property) => {
+      organize_swagger_object_default(specification, parsedDocument, property);
+    });
+    return specification;
+  }
+  return {};
+});
+var commentsToOpenApi2 = (fileContents, verbose) => {
+  const jsDocumentComments = parse(fileContents, { spacing: "preserve" });
+  return jsDocumentComments.map((comment) => {
+    const loc = comment.tags.length + 1;
+    const result = mergeWith({}, ...tagsToObjects2(comment.tags, verbose), customizer_default);
+    ["definitions", "responses", "parameters", "securityDefinitions", "components", "tags"].forEach((property) => {
+      if (result[property] !== void 0 && hasEmptyProperty(result[property])) {
+        delete result[property];
+      }
+    });
+    const spec = JSON.parse(JSON.stringify(result));
+    return {
+      loc,
+      spec
+    };
+  });
+};
+var comments_to_open_api_default2 = commentsToOpenApi2;
+
+// ../path/dist/packem_shared/path-CR6YkPXX.js
+var DRIVE_LETTER_START_RE = /^[A-Z]:\//i;
+var normalizeWindowsPath = (input = "") => {
+  if (!input) {
+    return input;
+  }
+  return input.replaceAll("\\", "/").replace(DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+};
+var UNC_REGEX = /^[/\\]{2}/;
+var IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i;
+var DRIVE_LETTER_RE = /^[A-Z]:$/i;
+var cwd = () => {
+  if (typeof process.cwd === "function") {
+    return process.cwd().replaceAll("\\", "/");
+  }
+  return "/";
+};
+/^win/i.test(globalThis.process?.platform) ? ";" : ":";
+var normalizeString = (path2, allowAboveRoot) => {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (result.length < 2 || lastSegmentLength !== 2 || !result.endsWith(".") || result.at(-2) !== ".") {
+          if (result.length > 2) {
+            const lastSlashIndex = result.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              result = "";
+              lastSegmentLength = 0;
+            } else {
+              result = result.slice(0, lastSlashIndex);
+              lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (result.length > 0) {
+            result = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          result += result.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (result.length > 0) {
+          result += `/${path2.slice(lastSlash + 1, index)}`;
+        } else {
+          result = path2.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return result;
+};
+var isAbsolute = (path2) => IS_ABSOLUTE_RE.test(path2);
+var normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = UNC_REGEX.exec(path2);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2.at(-1) === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (DRIVE_LETTER_RE.test(path2)) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+var join = (...segments) => {
+  let path2 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path2.length > 0) {
+      const pathTrailing = path2[path2.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path2 += seg.slice(1);
+      } else {
+        path2 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path2 += seg;
+    }
+  }
+  return normalize(path2);
+};
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path2 = index >= 0 ? arguments_[index] : cwd();
+    if (!path2 || path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+var basename = (path2, extension) => {
+  const lastSegment = normalizeWindowsPath(path2).split("/").pop();
+  return lastSegment;
+};
+var __cjs_require = createRequire(import.meta.url);
+var __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+var __cjs_getBuiltinModule = (module) => {
+  if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+    const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require(module);
+};
+var {
+  fileURLToPath
+} = __cjs_getBuiltinModule("node:url");
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var binaryExtensions$1;
+var hasRequiredBinaryExtensions;
+function requireBinaryExtensions() {
+  if (hasRequiredBinaryExtensions) return binaryExtensions$1;
+  hasRequiredBinaryExtensions = 1;
+  binaryExtensions$1 = [
+    "3dm",
+    "3ds",
+    "3g2",
+    "3gp",
+    "7z",
+    "a",
+    "aac",
+    "adp",
+    "afdesign",
+    "afphoto",
+    "afpub",
+    "ai",
+    "aif",
+    "aiff",
+    "alz",
+    "ape",
+    "apk",
+    "appimage",
+    "ar",
+    "arj",
+    "asf",
+    "au",
+    "avi",
+    "bak",
+    "baml",
+    "bh",
+    "bin",
+    "bk",
+    "bmp",
+    "btif",
+    "bz2",
+    "bzip2",
+    "cab",
+    "caf",
+    "cgm",
+    "class",
+    "cmx",
+    "cpio",
+    "cr2",
+    "cr3",
+    "cur",
+    "dat",
+    "dcm",
+    "deb",
+    "dex",
+    "djvu",
+    "dll",
+    "dmg",
+    "dng",
+    "doc",
+    "docm",
+    "docx",
+    "dot",
+    "dotm",
+    "dra",
+    "DS_Store",
+    "dsk",
+    "dts",
+    "dtshd",
+    "dvb",
+    "dwg",
+    "dxf",
+    "ecelp4800",
+    "ecelp7470",
+    "ecelp9600",
+    "egg",
+    "eol",
+    "eot",
+    "epub",
+    "exe",
+    "f4v",
+    "fbs",
+    "fh",
+    "fla",
+    "flac",
+    "flatpak",
+    "fli",
+    "flv",
+    "fpx",
+    "fst",
+    "fvt",
+    "g3",
+    "gh",
+    "gif",
+    "graffle",
+    "gz",
+    "gzip",
+    "h261",
+    "h263",
+    "h264",
+    "icns",
+    "ico",
+    "ief",
+    "img",
+    "ipa",
+    "iso",
+    "jar",
+    "jpeg",
+    "jpg",
+    "jpgv",
+    "jpm",
+    "jxr",
+    "key",
+    "ktx",
+    "lha",
+    "lib",
+    "lvp",
+    "lz",
+    "lzh",
+    "lzma",
+    "lzo",
+    "m3u",
+    "m4a",
+    "m4v",
+    "mar",
+    "mdi",
+    "mht",
+    "mid",
+    "midi",
+    "mj2",
+    "mka",
+    "mkv",
+    "mmr",
+    "mng",
+    "mobi",
+    "mov",
+    "movie",
+    "mp3",
+    "mp4",
+    "mp4a",
+    "mpeg",
+    "mpg",
+    "mpga",
+    "mxu",
+    "nef",
+    "npx",
+    "numbers",
+    "nupkg",
+    "o",
+    "odp",
+    "ods",
+    "odt",
+    "oga",
+    "ogg",
+    "ogv",
+    "otf",
+    "ott",
+    "pages",
+    "pbm",
+    "pcx",
+    "pdb",
+    "pdf",
+    "pea",
+    "pgm",
+    "pic",
+    "png",
+    "pnm",
+    "pot",
+    "potm",
+    "potx",
+    "ppa",
+    "ppam",
+    "ppm",
+    "pps",
+    "ppsm",
+    "ppsx",
+    "ppt",
+    "pptm",
+    "pptx",
+    "psd",
+    "pya",
+    "pyc",
+    "pyo",
+    "pyv",
+    "qt",
+    "rar",
+    "ras",
+    "raw",
+    "resources",
+    "rgb",
+    "rip",
+    "rlc",
+    "rmf",
+    "rmvb",
+    "rpm",
+    "rtf",
+    "rz",
+    "s3m",
+    "s7z",
+    "scpt",
+    "sgi",
+    "shar",
+    "snap",
+    "sil",
+    "sketch",
+    "slk",
+    "smv",
+    "snk",
+    "so",
+    "stl",
+    "suo",
+    "sub",
+    "swf",
+    "tar",
+    "tbz",
+    "tbz2",
+    "tga",
+    "tgz",
+    "thmx",
+    "tif",
+    "tiff",
+    "tlz",
+    "ttc",
+    "ttf",
+    "txz",
+    "udf",
+    "uvh",
+    "uvi",
+    "uvm",
+    "uvp",
+    "uvs",
+    "uvu",
+    "viv",
+    "vob",
+    "war",
+    "wav",
+    "wax",
+    "wbmp",
+    "wdp",
+    "weba",
+    "webm",
+    "webp",
+    "whl",
+    "wim",
+    "wm",
+    "wma",
+    "wmv",
+    "wmx",
+    "woff",
+    "woff2",
+    "wrm",
+    "wvx",
+    "xbm",
+    "xif",
+    "xla",
+    "xlam",
+    "xls",
+    "xlsb",
+    "xlsm",
+    "xlsx",
+    "xlt",
+    "xltm",
+    "xltx",
+    "xm",
+    "xmind",
+    "xpi",
+    "xpm",
+    "xwd",
+    "xz",
+    "z",
+    "zip",
+    "zipx"
+  ];
+  return binaryExtensions$1;
+}
+var binaryExtensionsExports = /* @__PURE__ */ requireBinaryExtensions();
+var binaryExtensions = /* @__PURE__ */ getDefaultExportFromCjs(binaryExtensionsExports);
+new Set(binaryExtensions);
+var toPath = (urlOrPath) => normalizeWindowsPath(urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath);
+
+// ../fs/dist/packem_shared/WalkError-DUdQd6FT.js
+var WalkError = class extends Error {
+  /** File path of the root that's being walked. */
+  root;
+  /**
+   * Constructs a new instance.
+   * @param cause The underlying error or reason for the walk failure.
+   * @param root The root directory path where the walk operation started or encountered the error.
+   */
+  constructor(cause, root) {
+    super(`${cause instanceof Error ? cause.message : cause} for path "${root}"`);
+    this.cause = cause;
+    this.root = root;
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get name() {
+    return "WalkError";
+  }
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/explicit-module-boundary-types
+  set name(_name) {
+    throw new Error("Cannot overwrite name of WalkError");
+  }
+};
+
+// ../fs/dist/packem_shared/assertValidFileOrDirectoryPath-8HANmVjk.js
+var assertValidFileOrDirectoryPath = (fileOrDirectoryPath) => {
+  if (!fileOrDirectoryPath || !(fileOrDirectoryPath instanceof URL) && typeof fileOrDirectoryPath !== "string") {
+    throw new TypeError("Path must be a non-empty string or URL.");
+  }
+};
+
+// ../fs/dist/packem_shared/walk-include-CZco7BvN.js
+var globToRegExp = (glob) => {
+  const reString = glob.replace(/\.\*/g, ".([^/]*)").replace(/\*\*/g, "(.*)").replace(/(?<!\.)\*(?!\*)/g, "([^/]*)").replace(/\?/g, "[^/]").replace(/\.(?!\*)/g, String.raw`\.`).replace(/\{/g, "(").replace(/\}/g, ")").replace(/,/g, "|").replace(/\[!(.*?)\]/g, "[^$1]");
+  return new RegExp(`^${reString}$`);
+};
+var walkInclude = (path2, extensions2, match, skip) => {
+  if (Array.isArray(extensions2) && extensions2.length > 0 && !extensions2.some((extension) => path2.endsWith(extension))) {
+    return false;
+  }
+  if (match && !match.some((pattern) => pattern.test(path2))) {
+    return false;
+  }
+  return !skip?.some((pattern) => pattern.test(path2));
+};
+
+// ../fs/dist/packem_shared/walk-BhTbpr3y.js
+var __cjs_require2 = createRequire(import.meta.url);
+var __cjs_getProcess2 = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+var __cjs_getBuiltinModule2 = (module) => {
+  if (typeof __cjs_getProcess2 !== "undefined" && __cjs_getProcess2.versions && __cjs_getProcess2.versions.node) {
+    const [major, minor] = __cjs_getProcess2.versions.node.split(".").map(Number);
+    if (major > 22 || major === 22 && minor >= 3 || major === 20 && minor >= 16) {
+      return __cjs_getProcess2.getBuiltinModule(module);
+    }
+  }
+  return __cjs_require2(module);
+};
+var {
+  readdir,
+  realpath,
+  stat
+} = __cjs_getBuiltinModule2("node:fs/promises");
+var _createWalkEntry = async (path2) => {
+  const normalizePath = normalize(path2);
+  const name = basename(normalizePath);
+  const info = await stat(normalizePath);
+  return {
+    isDirectory: () => info.isDirectory(),
+    isFile: () => info.isFile(),
+    isSymbolicLink: () => info.isSymbolicLink(),
+    name,
+    path: normalizePath
+  };
+};
+async function* walk(directory, {
+  extensions: extensions2,
+  followSymlinks = false,
+  includeDirs: includeDirectories = true,
+  includeFiles = true,
+  includeSymlinks = true,
+  match,
+  maxDepth = Number.POSITIVE_INFINITY,
+  skip
+} = {}) {
+  assertValidFileOrDirectoryPath(directory);
+  if (maxDepth < 0) {
+    return;
+  }
+  const mappedMatch = match ? match.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
+  const mappedSkip = skip ? skip.map((pattern) => typeof pattern === "string" ? globToRegExp(pattern) : pattern) : void 0;
+  directory = resolve(toPath(directory));
+  if (includeDirectories && walkInclude(directory, extensions2, mappedMatch, mappedSkip)) {
+    yield await _createWalkEntry(directory);
+  }
+  if (maxDepth < 1 || !walkInclude(directory, void 0, void 0, mappedSkip)) {
+    return;
+  }
+  try {
+    for await (const entry of await readdir(directory, {
+      withFileTypes: true
+    })) {
+      let path2 = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        if (followSymlinks) {
+          path2 = await realpath(path2);
+        } else if (includeSymlinks && walkInclude(path2, extensions2, mappedMatch, mappedSkip)) {
+          yield {
+            isDirectory: entry.isDirectory,
+            isFile: entry.isFile,
+            isSymbolicLink: entry.isSymbolicLink,
+            name: entry.name,
+            path: path2
+          };
+        } else {
+          continue;
+        }
+      }
+      if (entry.isSymbolicLink() || entry.isDirectory()) {
+        yield* walk(path2, {
+          extensions: extensions2,
+          followSymlinks,
+          includeDirs: includeDirectories,
+          includeFiles,
+          includeSymlinks,
+          match: mappedMatch,
+          maxDepth: maxDepth - 1,
+          skip: mappedSkip
+        });
+      } else if (entry.isFile() && includeFiles && walkInclude(path2, extensions2, mappedMatch, mappedSkip)) {
+        yield {
+          isDirectory: () => entry.isDirectory(),
+          isFile: () => entry.isFile(),
+          isSymbolicLink: () => entry.isSymbolicLink(),
+          name: entry.name,
+          path: path2
+        };
+      }
+    }
+  } catch (error) {
+    if (error instanceof WalkError) {
+      throw error;
+    }
+    throw new WalkError(error, directory);
+  }
+}
+
+// ../fs/dist/packem_shared/collect-DcBwsYYd.js
+var collect = async (directory, options = {}) => {
+  if (!Array.isArray(options.extensions)) {
+    options.extensions = ["js", "mjs", "cjs", "ts"];
+  }
+  const entries = [];
+  for await (const entry of walk(directory, options)) {
+    entries.push(entry.path);
+  }
+  return entries;
+};
+
+// src/constants.ts
+var DEFAULT_EXCLUDE = [
+  "coverage/**",
+  ".github/**",
+  "**/*.d.ts",
+  "**/test{,s}/**",
+  "**/test{,-*}.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}",
+  "**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx,yaml,yml}",
+  "**/__tests__/**",
+  "**/{ava,babel,nyc}.config.{js,cjs,mjs}",
+  "**/jest.config.{js,cjs,mjs,ts}",
+  "**/{karma,rollup,webpack}.config.js",
+  "**/.{eslint,mocha}rc.{js,cjs}",
+  "**/.{travis,yarnrc}.yml",
+  "**/{docker-compose,docker}.yml",
+  "**/.yamllint.{yaml,yml}",
+  "**/node_modules/**",
+  "**/{pnpm-workspace,pnpm-lock}.yaml",
+  "**/{package,package-lock}.json",
+  "**/yarn.lock",
+  "**/package.json5",
+  "**/.next/**"
+];
+var validate = async (spec) => {
+  await SwaggerParser.validate(spec);
+};
+var validate_default = validate;
+
+export { DEFAULT_EXCLUDE, collect, comments_to_open_api_default, comments_to_open_api_default2, parse_file_default, spec_builder_default, validate_default, yaml_loc_default };
+//# sourceMappingURL=chunk-WUINTXB7.mjs.map
+//# sourceMappingURL=chunk-WUINTXB7.mjs.map