@visulima/jsdoc-open-api 3.0.0-alpha.4 → 3.0.0-alpha.6

package/dist/chunk-PTFTJY7I.js

@@ -1,1233 +0,0 @@
-'use strict';
-
-var commentParser = require('comment-parser');
-var mergeWith = require('lodash.mergewith');
-var fs = require('fs');
-var path = require('path');
-var yaml = require('yaml');
-var module$1 = require('module');
-var SwaggerParser = require('@apidevtools/swagger-parser');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var mergeWith__default = /*#__PURE__*/_interopDefault(mergeWith);
-var path__default = /*#__PURE__*/_interopDefault(path);
-var yaml__default = /*#__PURE__*/_interopDefault(yaml);
-var SwaggerParser__default = /*#__PURE__*/_interopDefault(SwaggerParser);
-
-// ../../../node_modules/.pnpm/tsup@8.5.1_@swc+core@1.13.5_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-
-// 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 = commentParser.parse(fileContents, { spacing: "preserve" });
-  return jsDocumentComments.filter((comment) => openAPIRegex.test(comment.description.trim())).map((comment) => {
-    const loc = comment.tags.length + 1;
-    const result = mergeWith__default.default({}, ...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 = fs.readFileSync(file, { encoding: "utf8" });
-  const extension = path__default.default.extname(file);
-  if (extension === ".yaml" || extension === ".yml") {
-    const spec = yaml__default.default.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__default.default({}, 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) => {
-  const hasContent = spec.description !== "" || spec.name !== void 0 && (spec.name.startsWith("/") || spec.name.endsWith(":"));
-  if ((spec.tag === "openapi" || spec.tag === "swagger" || spec.tag === "asyncapi") && hasContent) {
-    let yamlContent = spec.description;
-    if (spec.name !== void 0 && (spec.name.startsWith("/") || spec.name.endsWith(":"))) {
-      if (yamlContent.trim() === "") {
-        yamlContent = spec.name;
-      } else {
-        yamlContent = `${spec.name}
-${yamlContent}`;
-      }
-    }
-    const parsed = yaml__default.default.parseDocument(yamlContent);
-    if (parsed.errors.length > 0) {
-      parsed.errors.map((error) => {
-        const newError = error;
-        newError.annotation = yamlContent;
-        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 = commentParser.parse(fileContents, { spacing: "preserve" });
-  return jsDocumentComments.map((comment) => {
-    const loc = comment.tags.length + 1;
-    const result = mergeWith__default.default({}, ...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;
-
-// ../../filesystem/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 = module$1.createRequire(importMetaUrl);
-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);
-
-// ../../filesystem/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");
-  }
-};
-
-// ../../filesystem/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.");
-  }
-};
-
-// ../../filesystem/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));
-};
-
-// ../../filesystem/fs/dist/packem_shared/walk-BhTbpr3y.js
-var __cjs_require2 = module$1.createRequire(importMetaUrl);
-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);
-  }
-}
-
-// ../../filesystem/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__default.default.validate(spec);
-};
-var validate_default = validate;
-
-exports.DEFAULT_EXCLUDE = DEFAULT_EXCLUDE;
-exports.collect = collect;
-exports.comments_to_open_api_default = comments_to_open_api_default;
-exports.comments_to_open_api_default2 = comments_to_open_api_default2;
-exports.parse_file_default = parse_file_default;
-exports.spec_builder_default = spec_builder_default;
-exports.validate_default = validate_default;
-exports.yaml_loc_default = yaml_loc_default;
-//# sourceMappingURL=chunk-PTFTJY7I.js.map
-//# sourceMappingURL=chunk-PTFTJY7I.js.map