@xyd-js/openapi 0.1.0-build.168

package/dist/index.js

@@ -0,0 +1,2119 @@
+// src/const.ts
+var SUPPORTED_HTTP_METHODS = [
+  "get",
+  "put",
+  "patch",
+  "post",
+  "delete"
+  // 'options',
+  // 'head',
+  // 'trace'
+];
+var BUILT_IN_PROPERTIES = {
+  "__internal_getRefPath": true
+};
+
+// src/oas-core.ts
+import {
+  DEFINED_DEFINITION_PROPERTY_TYPE
+} from "@xyd-js/uniform";
+function schemaObjectToUniformDefinitionProperties(schemaObject, rootProperty, visitedRefs) {
+  var _a, _b;
+  if ("$ref" in schemaObject) {
+    console.warn("Reference objects are not supported in schemaObjectToUniformDefinitionProperties");
+    return null;
+  }
+  const properties = [];
+  if ("anyOf" in schemaObject && schemaObject.anyOf) {
+    const property = schemaObjectToUniformDefinitionProperty("", schemaObject, false, false, visitedRefs);
+    if (property) {
+      if (rootProperty) {
+        return property;
+      }
+      properties.push(property);
+    }
+  } else if ("oneOf" in schemaObject && schemaObject.oneOf) {
+    const property = schemaObjectToUniformDefinitionProperty("", schemaObject, false, false, visitedRefs);
+    if (property) {
+      if (rootProperty) {
+        return property;
+      }
+      properties.push(property);
+    }
+  } else if ("allOf" in schemaObject && schemaObject.allOf) {
+    const componentPaths = [];
+    for (const schema of schemaObject.allOf) {
+      if ("$ref" in schema) {
+        console.warn("$ref is not supported in allOf schemas");
+        continue;
+      }
+      const oasSchema2 = schema;
+      if (oasSchema2.__internal_getRefPath) {
+        const refPath = oasSchema2.__internal_getRefPath();
+        if (typeof refPath === "string") {
+          componentPaths.push(refPath);
+        } else if (Array.isArray(refPath)) {
+          componentPaths.push(...refPath);
+        } else {
+          console.warn("Invalid refPath type in allOf schema", oasSchema2);
+        }
+      }
+      if ("properties" in schema && schema.properties) {
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+          if (BUILT_IN_PROPERTIES[propName]) {
+            continue;
+          }
+          if ("$ref" in propSchema) {
+            console.warn("$ref is not supported in allOf properties");
+            continue;
+          }
+          const property = schemaObjectToUniformDefinitionProperty(
+            propName,
+            propSchema,
+            (_a = schema.required) == null ? void 0 : _a.includes(propName),
+            (propSchema == null ? void 0 : propSchema.type) === "array" ? true : false,
+            visitedRefs
+          );
+          if (property) {
+            const existingPropertyIndex = properties.findIndex((p) => p.name === propName);
+            if (existingPropertyIndex >= 0) {
+              const existingProperty = properties[existingPropertyIndex];
+              properties[existingPropertyIndex] = {
+                ...existingProperty,
+                ...property,
+                description: property.description || existingProperty.description || "",
+                meta: [...existingProperty.meta || [], ...property.meta || []]
+              };
+            } else {
+              properties.push(property);
+            }
+          }
+        }
+      }
+    }
+    const oasSchema = schemaObject;
+    oasSchema.__internal_getRefPath = () => componentPaths;
+  } else if ("properties" in schemaObject && schemaObject.properties) {
+    for (const [propName, propSchema] of Object.entries(schemaObject.properties)) {
+      if (BUILT_IN_PROPERTIES[propName]) {
+        continue;
+      }
+      if (typeof propSchema === "object" && "$ref" in propSchema) {
+        console.warn("$ref is not supported in properties");
+        continue;
+      }
+      const property = schemaObjectToUniformDefinitionProperty(
+        propName,
+        propSchema,
+        (_b = schemaObject.required) == null ? void 0 : _b.includes(propName),
+        (propSchema == null ? void 0 : propSchema.type) === "array" ? true : false,
+        visitedRefs
+      );
+      if (property) {
+        properties.push(property);
+      }
+    }
+  }
+  return properties;
+}
+function schemaObjectToUniformDefinitionProperty(name, schema, required, arrayOf, visitedRefs, parentProperty) {
+  var _a, _b, _c, _d;
+  if (name === "__UNSAFE_refPath") {
+    return null;
+  }
+  if (!schema) return null;
+  if (!visitedRefs) {
+    visitedRefs = /* @__PURE__ */ new Map();
+  }
+  let refPath = "";
+  if ("__UNSAFE_refPath" in schema && typeof schema.__UNSAFE_refPath === "function") {
+    refPath = schema.__UNSAFE_refPath();
+    const defProp = visitedRefs.get(refPath);
+    if (defProp) {
+      return JSON.parse(JSON.stringify(defProp));
+    }
+  }
+  if (parentProperty) {
+    visitedRefs.set(refPath, parentProperty);
+  }
+  if ("anyOf" in schema && schema.anyOf) {
+    const componentPaths = [];
+    const properties = [];
+    for (const variantSchema of schema.anyOf) {
+      if ("$ref" in variantSchema) {
+        console.warn("$ref is not supported in anyOf schemas");
+        continue;
+      }
+      const oasSchema2 = variantSchema;
+      if (oasSchema2.__internal_getRefPath) {
+        const refPath2 = oasSchema2.__internal_getRefPath();
+        if (typeof refPath2 === "string") {
+          componentPaths.push(refPath2);
+        } else if (Array.isArray(refPath2)) {
+          componentPaths.push(...refPath2);
+        } else {
+          console.warn("Invalid refPath type in anyOf schema", oasSchema2);
+        }
+      }
+      const property2 = schemaObjectToUniformDefinitionProperty(name, variantSchema, required, false, visitedRefs);
+      if (property2) {
+        if (isMergeType(property2.type)) {
+          properties.push(...property2.properties || []);
+        } else {
+          properties.push({
+            ...property2,
+            name: variantSchema.title || property2.name || ""
+          });
+        }
+      }
+    }
+    const oasSchema = schema;
+    oasSchema.__internal_getRefPath = () => componentPaths;
+    const prop = {
+      name,
+      type: DEFINED_DEFINITION_PROPERTY_TYPE.UNION,
+      description: schema.description || "",
+      properties
+    };
+    if (refPath) {
+      visitedRefs.set(refPath, prop);
+    }
+    return prop;
+  }
+  const meta = schemaObjectToUniformDefinitionPropertyMeta({
+    ...schema,
+    required: required ? [name] : void 0
+  }, name);
+  if ("oneOf" in schema && schema.oneOf) {
+    const componentPaths = [];
+    const properties = [];
+    for (const variantSchema of schema.oneOf) {
+      if ("$ref" in variantSchema) {
+        console.warn("$ref is not supported in oneOf schemas");
+        continue;
+      }
+      const oasSchema2 = variantSchema;
+      if (oasSchema2.__internal_getRefPath) {
+        const refPath2 = oasSchema2.__internal_getRefPath();
+        if (typeof refPath2 === "string") {
+          componentPaths.push(refPath2);
+        } else if (Array.isArray(refPath2)) {
+          componentPaths.push(...refPath2);
+        } else {
+          console.warn("Invalid refPath type in allOf schema", oasSchema2);
+        }
+      }
+      const property2 = schemaObjectToUniformDefinitionProperty(name, variantSchema, required, false, visitedRefs);
+      if (property2) {
+        properties.push({
+          ...property2,
+          name: variantSchema.title || property2.name || ""
+        });
+      }
+    }
+    const oasSchema = schema;
+    oasSchema.__internal_getRefPath = () => componentPaths;
+    const prop = {
+      name,
+      type: DEFINED_DEFINITION_PROPERTY_TYPE.XOR,
+      description: schema.description || "",
+      properties,
+      meta
+    };
+    if (refPath) {
+      visitedRefs.set(refPath, prop);
+    }
+    return prop;
+  }
+  if ("allOf" in schema && schema.allOf) {
+    const componentPaths = [];
+    const mergedProperty = {
+      name,
+      type: schema.type || "",
+      description: schema.description || "",
+      properties: [],
+      meta
+    };
+    for (const variantSchema of schema.allOf) {
+      if ("$ref" in variantSchema) {
+        console.warn("$ref is not supported in allOf schemas");
+        continue;
+      }
+      const oasSchema2 = variantSchema;
+      if (oasSchema2.__internal_getRefPath) {
+        const refPath2 = oasSchema2.__internal_getRefPath();
+        if (typeof refPath2 === "string") {
+          componentPaths.push(refPath2);
+        } else if (Array.isArray(refPath2)) {
+          componentPaths.push(...refPath2);
+        } else {
+          console.warn("Invalid refPath type in allOf schema", oasSchema2);
+        }
+      }
+      if (!mergedProperty.type) {
+        if (typeof variantSchema.type === "string") {
+          mergedProperty.type = variantSchema.type || "";
+        }
+      }
+      if ("properties" in variantSchema && variantSchema.properties) {
+        for (const [propName, propSchema] of Object.entries(variantSchema.properties)) {
+          if (BUILT_IN_PROPERTIES[propName]) {
+            continue;
+          }
+          if ("$ref" in propSchema) {
+            console.warn("$ref is not supported in allOf properties");
+            continue;
+          }
+          const property2 = schemaObjectToUniformDefinitionProperty(
+            propName,
+            propSchema,
+            (_a = variantSchema.required) == null ? void 0 : _a.includes(propName),
+            false,
+            visitedRefs
+          );
+          if (property2 && mergedProperty.properties) {
+            const existingPropertyIndex = mergedProperty.properties.findIndex((p) => p.name === propName);
+            if (existingPropertyIndex >= 0) {
+              const existingProperty = mergedProperty.properties[existingPropertyIndex];
+              mergedProperty.properties[existingPropertyIndex] = {
+                ...existingProperty,
+                ...property2,
+                description: property2.description || existingProperty.description || "",
+                meta: [...existingProperty.meta || [], ...property2.meta || []]
+              };
+            } else {
+              mergedProperty.properties.push(property2);
+            }
+          }
+        }
+      } else {
+        const property2 = schemaObjectToUniformDefinitionProperty(
+          "",
+          variantSchema,
+          false,
+          false,
+          visitedRefs
+        );
+        if (property2) {
+          if (isOfType(property2.type)) {
+            mergedProperty.ofProperty = property2;
+          } else {
+            if (!((_b = mergedProperty.properties) == null ? void 0 : _b.length)) {
+              mergedProperty.properties = [];
+            }
+            if (mergedProperty.ofProperty) {
+              mergedProperty.description = property2.description || mergedProperty.ofProperty.description || "";
+            } else {
+              mergedProperty.properties.push(property2);
+            }
+          }
+        }
+      }
+    }
+    const oasSchema = schema;
+    oasSchema.__internal_getRefPath = () => componentPaths;
+    if (refPath) {
+      visitedRefs.set(refPath, mergedProperty);
+    }
+    return mergedProperty;
+  }
+  const property = {
+    name,
+    type: schema.type || "object",
+    description: schema.description || "",
+    meta
+  };
+  if (schema.enum) {
+    const enumProperties = schemaObjectToUniformDefinitionProperties({
+      properties: schema.enum.reduce((acc, enumName) => ({
+        ...acc,
+        [enumName]: {
+          type: schema.type
+        }
+      }), {})
+    });
+    if (!Array.isArray(enumProperties)) {
+      return property;
+    }
+    meta.push({
+      name: "enum-type",
+      value: schema.type
+    });
+    const enumProperty = {
+      name,
+      type: DEFINED_DEFINITION_PROPERTY_TYPE.ENUM,
+      description: schema.description || "",
+      meta,
+      properties: enumProperties || []
+    };
+    if (refPath) {
+      visitedRefs.set(refPath, enumProperty);
+    }
+    return enumProperty;
+  } else {
+    if ("properties" in schema && schema.properties) {
+      property.properties = [];
+      for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        if (BUILT_IN_PROPERTIES[propName]) {
+          continue;
+        }
+        if ("$ref" in propSchema) {
+          console.warn("$ref is not supported in properties");
+          continue;
+        }
+        const nestedProperty = schemaObjectToUniformDefinitionProperty(
+          propName,
+          propSchema,
+          (_c = schema.required) == null ? void 0 : _c.includes(propName),
+          (propSchema == null ? void 0 : propSchema.type) === "array" ? true : false,
+          visitedRefs
+        );
+        if (nestedProperty) {
+          property.properties.push(nestedProperty);
+        }
+      }
+    } else if (schema.type === "array" && schema.items && !("$ref" in schema.items)) {
+      const arrayProperty = {
+        name,
+        type: DEFINED_DEFINITION_PROPERTY_TYPE.ARRAY,
+        description: schema.description || "",
+        meta,
+        properties: []
+      };
+      const itemsProperty = schemaObjectToUniformDefinitionProperty("", schema.items, required, true, visitedRefs, arrayProperty);
+      if (itemsProperty) {
+        if (arrayOf || isOfType(itemsProperty.type) || ((_d = itemsProperty.ofProperty) == null ? void 0 : _d.type)) {
+          arrayProperty.ofProperty = {
+            name: "",
+            type: itemsProperty.type,
+            properties: itemsProperty.properties || [],
+            description: itemsProperty.description || "",
+            meta: itemsProperty.meta || [],
+            ofProperty: itemsProperty.ofProperty || void 0
+          };
+        } else {
+          arrayProperty.properties = [itemsProperty];
+        }
+      }
+      if (refPath) {
+        visitedRefs.set(refPath, arrayProperty);
+      }
+      return arrayProperty;
+    }
+  }
+  if (arrayOf) {
+    const prop = {
+      type: property.type,
+      name: "",
+      description: "",
+      ofProperty: property
+    };
+    if (refPath) {
+      visitedRefs.set(refPath, prop);
+    }
+  }
+  if (refPath) {
+    visitedRefs.set(refPath, property);
+  }
+  return property;
+}
+function schemaObjectToUniformDefinitionPropertyMeta(objProp, name) {
+  const meta = [];
+  if (!objProp) {
+    return meta;
+  }
+  if (typeof objProp.required === "boolean" && objProp.required) {
+    meta.push({
+      name: "required",
+      value: "true"
+    });
+  } else if (Array.isArray(objProp.required)) {
+    for (const req of objProp.required) {
+      if (req === name) {
+        meta.push({
+          name: "required",
+          value: "true"
+        });
+      }
+    }
+  }
+  if (objProp.deprecated) {
+    meta.push({
+      name: "deprecated",
+      value: "true"
+    });
+  }
+  if ("default" in objProp) {
+    meta.push({
+      name: "defaults",
+      value: objProp.default
+    });
+  }
+  if ("nullable" in objProp) {
+    meta.push({
+      name: "nullable",
+      value: "true"
+    });
+  }
+  if ("example" in objProp) {
+    const example = typeof objProp.example === "object" ? JSON.stringify(objProp.example) : objProp.example;
+    meta.push({
+      name: "example",
+      value: example
+    });
+  }
+  if ("examples" in objProp) {
+    meta.push({
+      name: "examples",
+      value: objProp.examples
+    });
+  }
+  if ("maximum" in objProp) {
+    meta.push({
+      name: "maximum",
+      value: objProp.maximum
+    });
+  }
+  if ("minimum" in objProp) {
+    meta.push({
+      name: "minimum",
+      value: objProp.minimum
+    });
+  }
+  return meta;
+}
+function isMergeType(type) {
+  return type === DEFINED_DEFINITION_PROPERTY_TYPE.XOR || type === DEFINED_DEFINITION_PROPERTY_TYPE.UNION;
+}
+function isOfType(type) {
+  return type === DEFINED_DEFINITION_PROPERTY_TYPE.XOR || type === DEFINED_DEFINITION_PROPERTY_TYPE.UNION || type === DEFINED_DEFINITION_PROPERTY_TYPE.ARRAY;
+}
+
+// src/converters/oas-parameters.ts
+function oapParametersToDefinitionProperties(parameters) {
+  const parameterIn = {};
+  parameters.forEach((param) => {
+    if (!parameterIn[param.in]) {
+      parameterIn[param.in] = [];
+    }
+    const schema = param.schema;
+    const meta = [
+      ...schemaObjectToUniformDefinitionPropertyMeta(schema, param.name) || [],
+      ...schemaObjectToUniformDefinitionPropertyMeta(param, param.name) || []
+    ];
+    let oapV2Type = "";
+    if ("type" in param) {
+      oapV2Type = param.type;
+    }
+    const property = {
+      name: param.name,
+      type: (schema == null ? void 0 : schema.type) || oapV2Type || "",
+      description: param.description || "",
+      meta
+    };
+    parameterIn[param.in].push(property);
+  });
+  return parameterIn;
+}
+
+// src/converters/oas-paths.ts
+import {
+  ReferenceCategory
+} from "@xyd-js/uniform";
+
+// src/converters/oas-requestBody.ts
+import { DEFINED_DEFINITION_PROPERTY_TYPE as DEFINED_DEFINITION_PROPERTY_TYPE2 } from "@xyd-js/uniform";
+function oapRequestBodyToDefinitionProperties(reqBody, contentType) {
+  const schema = reqBody.content[contentType].schema;
+  if (!schema) {
+    return null;
+  }
+  let schemaObject;
+  if (schema.allOf || schema.anyOf || schema.oneOf) {
+    return schemaObjectToUniformDefinitionProperties(schema);
+  }
+  let array = false;
+  switch (schema.type) {
+    case "object": {
+      schemaObject = schema;
+      break;
+    }
+    case "array": {
+      const arrSchema = schema;
+      const items = arrSchema.items;
+      schemaObject = items;
+      array = true;
+      break;
+    }
+    default:
+      break;
+  }
+  if (!schemaObject) {
+    return null;
+  }
+  const properties = schemaObjectToUniformDefinitionProperties(schemaObject);
+  if (array) {
+    return {
+      type: DEFINED_DEFINITION_PROPERTY_TYPE2.ARRAY,
+      properties
+    };
+  }
+  return properties;
+}
+
+// src/converters/oas-responses.ts
+import { DEFINED_DEFINITION_PROPERTY_TYPE as DEFINED_DEFINITION_PROPERTY_TYPE3 } from "@xyd-js/uniform";
+function oasResponseToDefinitionProperties(responses, code, contentType) {
+  var _a;
+  let schemaObject;
+  let responseObject;
+  if (responses[code]) {
+    responseObject = responses[code];
+    if (!(responseObject == null ? void 0 : responseObject.content)) {
+      return null;
+    }
+    schemaObject = (_a = responseObject == null ? void 0 : responseObject.content[contentType]) == null ? void 0 : _a.schema;
+  }
+  if (!schemaObject) {
+    return {
+      properties: [
+        {
+          description: (responseObject == null ? void 0 : responseObject.description) || "",
+          name: "",
+          type: ""
+        }
+      ]
+    };
+  }
+  let array = false;
+  switch (schemaObject.type) {
+    case "array":
+      const arrSchema = schemaObject;
+      const items = arrSchema.items;
+      schemaObject = items;
+      array = true;
+    default:
+      break;
+  }
+  const properties = schemaObjectToUniformDefinitionProperties(schemaObject, true);
+  let description = "";
+  if (schemaObject.allOf) {
+    for (const item of schemaObject.allOf) {
+      if ("description" in item) {
+        description += item.description + "\n";
+      }
+    }
+  }
+  if (array) {
+    return {
+      properties: {
+        type: DEFINED_DEFINITION_PROPERTY_TYPE3.ARRAY,
+        properties
+      }
+    };
+  }
+  return {
+    properties: properties || [],
+    description: description || ""
+  };
+}
+
+// src/utils.ts
+import path from "path";
+import fs from "fs/promises";
+import yaml from "js-yaml";
+
+// ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/regex.js
+var regex = /[\0-\x1F!-,\.\/:-@\[-\^`\{-\xA9\xAB-\xB4\xB6-\xB9\xBB-\xBF\xD7\xF7\u02C2-\u02C5\u02D2-\u02DF\u02E5-\u02EB\u02ED\u02EF-\u02FF\u0375\u0378\u0379\u037E\u0380-\u0385\u0387\u038B\u038D\u03A2\u03F6\u0482\u0530\u0557\u0558\u055A-\u055F\u0589-\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05EB-\u05EE\u05F3-\u060F\u061B-\u061F\u066A-\u066D\u06D4\u06DD\u06DE\u06E9\u06FD\u06FE\u0700-\u070F\u074B\u074C\u07B2-\u07BF\u07F6-\u07F9\u07FB\u07FC\u07FE\u07FF\u082E-\u083F\u085C-\u085F\u086B-\u089F\u08B5\u08C8-\u08D2\u08E2\u0964\u0965\u0970\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09F2-\u09FB\u09FD\u09FF\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF0-\u0AF8\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B54\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B70\u0B72-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BF0-\u0BFF\u0C0D\u0C11\u0C29\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5B-\u0C5F\u0C64\u0C65\u0C70-\u0C7F\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0CFF\u0D0D\u0D11\u0D45\u0D49\u0D4F-\u0D53\u0D58-\u0D5E\u0D64\u0D65\u0D70-\u0D79\u0D80\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DE5\u0DF0\u0DF1\u0DF4-\u0E00\u0E3B-\u0E3F\u0E4F\u0E5A-\u0E80\u0E83\u0E85\u0E8B\u0EA4\u0EA6\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F01-\u0F17\u0F1A-\u0F1F\u0F2A-\u0F34\u0F36\u0F38\u0F3A-\u0F3D\u0F48\u0F6D-\u0F70\u0F85\u0F98\u0FBD-\u0FC5\u0FC7-\u0FFF\u104A-\u104F\u109E\u109F\u10C6\u10C8-\u10CC\u10CE\u10CF\u10FB\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u1360-\u137F\u1390-\u139F\u13F6\u13F7\u13FE-\u1400\u166D\u166E\u1680\u169B-\u169F\u16EB-\u16ED\u16F9-\u16FF\u170D\u1715-\u171F\u1735-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17D4-\u17D6\u17D8-\u17DB\u17DE\u17DF\u17EA-\u180A\u180E\u180F\u181A-\u181F\u1879-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191F\u192C-\u192F\u193C-\u1945\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DA-\u19FF\u1A1C-\u1A1F\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1AA6\u1AA8-\u1AAF\u1AC1-\u1AFF\u1B4C-\u1B4F\u1B5A-\u1B6A\u1B74-\u1B7F\u1BF4-\u1BFF\u1C38-\u1C3F\u1C4A-\u1C4C\u1C7E\u1C7F\u1C89-\u1C8F\u1CBB\u1CBC\u1CC0-\u1CCF\u1CD3\u1CFB-\u1CFF\u1DFA\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FBD\u1FBF-\u1FC1\u1FC5\u1FCD-\u1FCF\u1FD4\u1FD5\u1FDC-\u1FDF\u1FED-\u1FF1\u1FF5\u1FFD-\u203E\u2041-\u2053\u2055-\u2070\u2072-\u207E\u2080-\u208F\u209D-\u20CF\u20F1-\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211E-\u2123\u2125\u2127\u2129\u212E\u213A\u213B\u2140-\u2144\u214A-\u214D\u214F-\u215F\u2189-\u24B5\u24EA-\u2BFF\u2C2F\u2C5F\u2CE5-\u2CEA\u2CF4-\u2CFF\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D70-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E00-\u2E2E\u2E30-\u3004\u3008-\u3020\u3030\u3036\u3037\u303D-\u3040\u3097\u3098\u309B\u309C\u30A0\u30FB\u3100-\u3104\u3130\u318F-\u319F\u31C0-\u31EF\u3200-\u33FF\u4DC0-\u4DFF\u9FFD-\u9FFF\uA48D-\uA4CF\uA4FE\uA4FF\uA60D-\uA60F\uA62C-\uA63F\uA673\uA67E\uA6F2-\uA716\uA720\uA721\uA789\uA78A\uA7C0\uA7C1\uA7CB-\uA7F4\uA828-\uA82B\uA82D-\uA83F\uA874-\uA87F\uA8C6-\uA8CF\uA8DA-\uA8DF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA954-\uA95F\uA97D-\uA97F\uA9C1-\uA9CE\uA9DA-\uA9DF\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A-\uAA5F\uAA77-\uAA79\uAAC3-\uAADA\uAADE\uAADF\uAAF0\uAAF1\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F\uAB5B\uAB6A-\uAB6F\uABEB\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB29\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBB2-\uFBD2\uFD3E-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFC-\uFDFF\uFE10-\uFE1F\uFE30-\uFE32\uFE35-\uFE4C\uFE50-\uFE6F\uFE75\uFEFD-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF3E\uFF40\uFF5B-\uFF65\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFFF]|\uD800[\uDC0C\uDC27\uDC3B\uDC3E\uDC4E\uDC4F\uDC5E-\uDC7F\uDCFB-\uDD3F\uDD75-\uDDFC\uDDFE-\uDE7F\uDE9D-\uDE9F\uDED1-\uDEDF\uDEE1-\uDEFF\uDF20-\uDF2C\uDF4B-\uDF4F\uDF7B-\uDF7F\uDF9E\uDF9F\uDFC4-\uDFC7\uDFD0\uDFD6-\uDFFF]|\uD801[\uDC9E\uDC9F\uDCAA-\uDCAF\uDCD4-\uDCD7\uDCFC-\uDCFF\uDD28-\uDD2F\uDD64-\uDDFF\uDF37-\uDF3F\uDF56-\uDF5F\uDF68-\uDFFF]|\uD802[\uDC06\uDC07\uDC09\uDC36\uDC39-\uDC3B\uDC3D\uDC3E\uDC56-\uDC5F\uDC77-\uDC7F\uDC9F-\uDCDF\uDCF3\uDCF6-\uDCFF\uDD16-\uDD1F\uDD3A-\uDD7F\uDDB8-\uDDBD\uDDC0-\uDDFF\uDE04\uDE07-\uDE0B\uDE14\uDE18\uDE36\uDE37\uDE3B-\uDE3E\uDE40-\uDE5F\uDE7D-\uDE7F\uDE9D-\uDEBF\uDEC8\uDEE7-\uDEFF\uDF36-\uDF3F\uDF56-\uDF5F\uDF73-\uDF7F\uDF92-\uDFFF]|\uD803[\uDC49-\uDC7F\uDCB3-\uDCBF\uDCF3-\uDCFF\uDD28-\uDD2F\uDD3A-\uDE7F\uDEAA\uDEAD-\uDEAF\uDEB2-\uDEFF\uDF1D-\uDF26\uDF28-\uDF2F\uDF51-\uDFAF\uDFC5-\uDFDF\uDFF7-\uDFFF]|\uD804[\uDC47-\uDC65\uDC70-\uDC7E\uDCBB-\uDCCF\uDCE9-\uDCEF\uDCFA-\uDCFF\uDD35\uDD40-\uDD43\uDD48-\uDD4F\uDD74\uDD75\uDD77-\uDD7F\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDFF\uDE12\uDE38-\uDE3D\uDE3F-\uDE7F\uDE87\uDE89\uDE8E\uDE9E\uDEA9-\uDEAF\uDEEB-\uDEEF\uDEFA-\uDEFF\uDF04\uDF0D\uDF0E\uDF11\uDF12\uDF29\uDF31\uDF34\uDF3A\uDF45\uDF46\uDF49\uDF4A\uDF4E\uDF4F\uDF51-\uDF56\uDF58-\uDF5C\uDF64\uDF65\uDF6D-\uDF6F\uDF75-\uDFFF]|\uD805[\uDC4B-\uDC4F\uDC5A-\uDC5D\uDC62-\uDC7F\uDCC6\uDCC8-\uDCCF\uDCDA-\uDD7F\uDDB6\uDDB7\uDDC1-\uDDD7\uDDDE-\uDDFF\uDE41-\uDE43\uDE45-\uDE4F\uDE5A-\uDE7F\uDEB9-\uDEBF\uDECA-\uDEFF\uDF1B\uDF1C\uDF2C-\uDF2F\uDF3A-\uDFFF]|\uD806[\uDC3B-\uDC9F\uDCEA-\uDCFE\uDD07\uDD08\uDD0A\uDD0B\uDD14\uDD17\uDD36\uDD39\uDD3A\uDD44-\uDD4F\uDD5A-\uDD9F\uDDA8\uDDA9\uDDD8\uDDD9\uDDE2\uDDE5-\uDDFF\uDE3F-\uDE46\uDE48-\uDE4F\uDE9A-\uDE9C\uDE9E-\uDEBF\uDEF9-\uDFFF]|\uD807[\uDC09\uDC37\uDC41-\uDC4F\uDC5A-\uDC71\uDC90\uDC91\uDCA8\uDCB7-\uDCFF\uDD07\uDD0A\uDD37-\uDD39\uDD3B\uDD3E\uDD48-\uDD4F\uDD5A-\uDD5F\uDD66\uDD69\uDD8F\uDD92\uDD99-\uDD9F\uDDAA-\uDEDF\uDEF7-\uDFAF\uDFB1-\uDFFF]|\uD808[\uDF9A-\uDFFF]|\uD809[\uDC6F-\uDC7F\uDD44-\uDFFF]|[\uD80A\uD80B\uD80E-\uD810\uD812-\uD819\uD824-\uD82B\uD82D\uD82E\uD830-\uD833\uD837\uD839\uD83D\uD83F\uD87B-\uD87D\uD87F\uD885-\uDB3F\uDB41-\uDBFF][\uDC00-\uDFFF]|\uD80D[\uDC2F-\uDFFF]|\uD811[\uDE47-\uDFFF]|\uD81A[\uDE39-\uDE3F\uDE5F\uDE6A-\uDECF\uDEEE\uDEEF\uDEF5-\uDEFF\uDF37-\uDF3F\uDF44-\uDF4F\uDF5A-\uDF62\uDF78-\uDF7C\uDF90-\uDFFF]|\uD81B[\uDC00-\uDE3F\uDE80-\uDEFF\uDF4B-\uDF4E\uDF88-\uDF8E\uDFA0-\uDFDF\uDFE2\uDFE5-\uDFEF\uDFF2-\uDFFF]|\uD821[\uDFF8-\uDFFF]|\uD823[\uDCD6-\uDCFF\uDD09-\uDFFF]|\uD82C[\uDD1F-\uDD4F\uDD53-\uDD63\uDD68-\uDD6F\uDEFC-\uDFFF]|\uD82F[\uDC6B-\uDC6F\uDC7D-\uDC7F\uDC89-\uDC8F\uDC9A-\uDC9C\uDC9F-\uDFFF]|\uD834[\uDC00-\uDD64\uDD6A-\uDD6C\uDD73-\uDD7A\uDD83\uDD84\uDD8C-\uDDA9\uDDAE-\uDE41\uDE45-\uDFFF]|\uD835[\uDC55\uDC9D\uDCA0\uDCA1\uDCA3\uDCA4\uDCA7\uDCA8\uDCAD\uDCBA\uDCBC\uDCC4\uDD06\uDD0B\uDD0C\uDD15\uDD1D\uDD3A\uDD3F\uDD45\uDD47-\uDD49\uDD51\uDEA6\uDEA7\uDEC1\uDEDB\uDEFB\uDF15\uDF35\uDF4F\uDF6F\uDF89\uDFA9\uDFC3\uDFCC\uDFCD]|\uD836[\uDC00-\uDDFF\uDE37-\uDE3A\uDE6D-\uDE74\uDE76-\uDE83\uDE85-\uDE9A\uDEA0\uDEB0-\uDFFF]|\uD838[\uDC07\uDC19\uDC1A\uDC22\uDC25\uDC2B-\uDCFF\uDD2D-\uDD2F\uDD3E\uDD3F\uDD4A-\uDD4D\uDD4F-\uDEBF\uDEFA-\uDFFF]|\uD83A[\uDCC5-\uDCCF\uDCD7-\uDCFF\uDD4C-\uDD4F\uDD5A-\uDFFF]|\uD83B[\uDC00-\uDDFF\uDE04\uDE20\uDE23\uDE25\uDE26\uDE28\uDE33\uDE38\uDE3A\uDE3C-\uDE41\uDE43-\uDE46\uDE48\uDE4A\uDE4C\uDE50\uDE53\uDE55\uDE56\uDE58\uDE5A\uDE5C\uDE5E\uDE60\uDE63\uDE65\uDE66\uDE6B\uDE73\uDE78\uDE7D\uDE7F\uDE8A\uDE9C-\uDEA0\uDEA4\uDEAA\uDEBC-\uDFFF]|\uD83C[\uDC00-\uDD2F\uDD4A-\uDD4F\uDD6A-\uDD6F\uDD8A-\uDFFF]|\uD83E[\uDC00-\uDFEF\uDFFA-\uDFFF]|\uD869[\uDEDE-\uDEFF]|\uD86D[\uDF35-\uDF3F]|\uD86E[\uDC1E\uDC1F]|\uD873[\uDEA2-\uDEAF]|\uD87A[\uDFE1-\uDFFF]|\uD87E[\uDE1E-\uDFFF]|\uD884[\uDF4B-\uDFFF]|\uDB40[\uDC00-\uDCFF\uDDF0-\uDFFF]/g;
+
+// ../../node_modules/.pnpm/github-slugger@2.0.0/node_modules/github-slugger/index.js
+var own = Object.hasOwnProperty;
+var BananaSlug = class {
+  /**
+   * Create a new slug class.
+   */
+  constructor() {
+    this.occurrences;
+    this.reset();
+  }
+  /**
+   * Generate a unique slug.
+  *
+  * Tracks previously generated slugs: repeated calls with the same value
+  * will result in different slugs.
+  * Use the `slug` function to get same slugs.
+   *
+   * @param  {string} value
+   *   String of text to slugify
+   * @param  {boolean} [maintainCase=false]
+   *   Keep the current case, otherwise make all lowercase
+   * @return {string}
+   *   A unique slug string
+   */
+  slug(value, maintainCase) {
+    const self = this;
+    let result = slug(value, maintainCase === true);
+    const originalSlug = result;
+    while (own.call(self.occurrences, result)) {
+      self.occurrences[originalSlug]++;
+      result = originalSlug + "-" + self.occurrences[originalSlug];
+    }
+    self.occurrences[result] = 0;
+    return result;
+  }
+  /**
+   * Reset - Forget all previous slugs
+   *
+   * @return void
+   */
+  reset() {
+    this.occurrences = /* @__PURE__ */ Object.create(null);
+  }
+};
+function slug(value, maintainCase) {
+  if (typeof value !== "string") return "";
+  if (!maintainCase) value = value.toLowerCase();
+  return value.replace(regex, "").replace(/ /g, "-");
+}
+
+// src/utils.ts
+import $refParser from "@apidevtools/json-schema-ref-parser";
+import { ReferenceType } from "@xyd-js/uniform";
+function slug2(str) {
+  const slugger = new BananaSlug();
+  return slugger.slug(str);
+}
+async function deferencedOpenAPI(openApiPath) {
+  const openApiSpec = await readOpenApiSpec(openApiPath);
+  if (!openApiSpec) {
+    return;
+  }
+  const cwd = process.cwd();
+  const remoteOasPath = openApiPath.startsWith("http://") || openApiPath.startsWith("https://") ? true : false;
+  const circularRefs = /* @__PURE__ */ new Set();
+  const options = {
+    dereference: {
+      onCircular(defPath) {
+        const v = `#${defPath.split("#")[1]}`;
+        circularRefs.add(v);
+      },
+      // circular: true, // ignore circular references,
+      // onCi
+      onDereference(defPath, value, parent) {
+        if (circularRefs.has(defPath) || circularRefs.has(path.join(defPath, "properties"))) {
+          value.__UNSAFE_circular = true;
+        }
+        if (value && typeof value === "object") {
+          value.__UNSAFE_refPath = () => defPath;
+        }
+        if (parent && typeof parent === "object") {
+          parent.__UNSAFE_refPath = () => defPath;
+        }
+      }
+    }
+  };
+  if (remoteOasPath) {
+    if (!options.resolve) {
+      options.resolve = {};
+    }
+    options.resolve.file = {
+      read: async (file) => {
+        let rel = path.relative(cwd, file.url);
+        rel = rel.split(path.sep).join("/");
+        const absoluteUrl = new URL(rel, openApiPath).href;
+        const res = await fetch(absoluteUrl);
+        if (!res.ok) {
+          throw new Error(`Failed to fetch ${absoluteUrl}: ${res.status}`);
+        }
+        let content;
+        if (file.extension === ".json" || file.extension === ".yaml" || file.extension === ".yml") {
+          if (file.extension === ".json") {
+            content = await res.json();
+          } else {
+            content = yaml.load(await res.text());
+          }
+        } else {
+          content = await res.text();
+        }
+        return content;
+      }
+    };
+  }
+  await $refParser.dereference(openApiSpec, options);
+  return openApiSpec;
+}
+async function readOpenApiSpec(filePath) {
+  let content;
+  let fromUrl = false;
+  if (filePath.startsWith("http://") || filePath.startsWith("https://")) {
+    const response = await fetch(filePath);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch OpenAPI spec from URL: ${response.statusText}`);
+    }
+    content = await response.text();
+    fromUrl = true;
+  } else {
+    try {
+      await fs.access(filePath);
+    } catch (error) {
+      console.log(`\u26A0\uFE0F "(openapi): ${filePath}" is defined in the docs.json navigation but the file does not exist.`);
+      return;
+    }
+    content = await fs.readFile(filePath, "utf-8");
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".yaml" || ext === ".yml") {
+    return yaml.load(content);
+  } else if (ext === ".json") {
+    return JSON.parse(content);
+  } else if (fromUrl && content.startsWith("{")) {
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON from URL: ${error}`);
+    }
+  } else {
+    throw new Error("Unsupported file format. Use JSON or YAML.");
+  }
+}
+function httpMethodToUniformMethod(method) {
+  switch (method) {
+    case "get":
+      return ReferenceType.REST_HTTP_GET;
+    case "put":
+      return ReferenceType.REST_HTTP_PUT;
+    case "patch":
+      return ReferenceType.REST_HTTP_PATCH;
+    case "post":
+      return ReferenceType.REST_HTTP_POST;
+    case "delete":
+      return ReferenceType.REST_HTTP_DELETE;
+    case "options":
+      return ReferenceType.REST_HTTP_OPTIONS;
+    case "head":
+      return ReferenceType.REST_HTTP_HEAD;
+    case "trace":
+      return ReferenceType.REST_HTTP_TRACE;
+    default:
+      return null;
+  }
+}
+
+// src/converters/oas-paths.ts
+import path2 from "path";
+function oapPathToReference(schema, httpMethod, path4, oapPath) {
+  const mType = httpMethodToUniformMethod(httpMethod);
+  if (!mType) {
+    console.error(`Unsupported method: ${httpMethod}`);
+    return null;
+  }
+  const definitions = [];
+  const exampleGroups = [];
+  const oapMethod = oapPath == null ? void 0 : oapPath[httpMethod];
+  if (!oapMethod) {
+    return null;
+  }
+  const tag = getFirstTag(oapMethod);
+  const group = [tag];
+  const endpointRef = {
+    title: title(oapMethod, httpMethod, path4),
+    canonical: canonical(oapMethod, httpMethod, path4),
+    description: (oapMethod == null ? void 0 : oapMethod.description) || (oapMethod == null ? void 0 : oapMethod.summary),
+    type: mType,
+    category: ReferenceCategory.REST,
+    context: {
+      method: httpMethod,
+      path: `${encodeURIComponent(path4)}`,
+      fullPath: path4,
+      group
+    },
+    examples: {
+      groups: exampleGroups
+    },
+    definitions
+  };
+  if (oapMethod.parameters) {
+    const parameters = oapMethod.parameters;
+    const paramtersMap = oapParametersToDefinitionProperties(parameters);
+    Object.entries(paramtersMap).forEach(([key, definitionProperties]) => {
+      let title2;
+      switch (key) {
+        case "path":
+          title2 = "Path parameters";
+          break;
+        case "query":
+          title2 = "Query parameters";
+          break;
+        case "header":
+          title2 = "Headers";
+          break;
+        default:
+          console.error(`Unsupported parameter type: ${key} for ${httpMethod} ${path4}`);
+          return;
+      }
+      definitions.push({
+        title: title2,
+        properties: definitionProperties
+      });
+    });
+  }
+  definitions.push(...oapOperationToDefinitions(oapMethod));
+  endpointRef.__UNSAFE_selector = function __UNSAFE_selector(selector) {
+    switch (selector) {
+      case "[schema]": {
+        return schema;
+      }
+      case "[method]": {
+        return {
+          oapPath,
+          httpMethod,
+          path: path4
+        };
+      }
+      case "[method] [path]": {
+        return oapMethod;
+      }
+      default:
+        return null;
+    }
+  };
+  return endpointRef;
+}
+function oapOperationToDefinitions(oapMethod) {
+  const definitions = [];
+  if (oapMethod.requestBody) {
+    const definition = oapRequestOperationToUniformDefinition(oapMethod);
+    definitions.push(definition);
+  }
+  if (oapMethod.responses) {
+    const definition = oapResponseOperationToUniformDefinition(oapMethod);
+    definitions.push(definition);
+  }
+  return definitions;
+}
+function oapRequestOperationToUniformDefinition(oapOperation) {
+  var _a;
+  const reqBody = oapOperation.requestBody;
+  const variants = [];
+  for (const contentType of Object.keys(reqBody.content)) {
+    const schema = (_a = reqBody.content[contentType]) == null ? void 0 : _a.schema;
+    let properties = [];
+    let rootProperty;
+    let propertiesResp = oapRequestBodyToDefinitionProperties(reqBody, contentType) || [];
+    if (Array.isArray(propertiesResp)) {
+      properties = propertiesResp;
+    } else {
+      rootProperty = propertiesResp;
+    }
+    const meta2 = [
+      {
+        name: "contentType",
+        value: contentType || ""
+      }
+    ];
+    if (schema == null ? void 0 : schema.required) {
+      meta2.push({
+        name: "required",
+        value: schema.required ? "true" : "false"
+      });
+    }
+    variants.push({
+      title: contentType,
+      description: schema.description || "",
+      properties,
+      rootProperty,
+      meta: meta2,
+      symbolDef: definitionPropertyTypeDef(schema)
+    });
+  }
+  const meta = [];
+  if (reqBody.required) {
+    meta.push({
+      name: "required",
+      value: "true"
+    });
+  }
+  return {
+    title: "Request body",
+    variants,
+    properties: [],
+    meta
+  };
+}
+function oapResponseOperationToUniformDefinition(oapOperation) {
+  const responses = oapOperation.responses;
+  const variants = [];
+  Object.keys(responses).forEach((code) => {
+    var _a;
+    const responseObject = responses[code];
+    if (!(responseObject == null ? void 0 : responseObject.content)) {
+      variants.push({
+        title: code,
+        description: responseObject.description,
+        properties: [],
+        meta: [
+          {
+            name: "status",
+            value: code || ""
+          }
+        ]
+      });
+      return null;
+    }
+    const contentTypes = Object.keys(responseObject.content);
+    for (const contentType of contentTypes) {
+      let properties = [];
+      let rootProperty;
+      const schema = (_a = responseObject.content[contentType]) == null ? void 0 : _a.schema;
+      const respProperties = oasResponseToDefinitionProperties(responses, code, contentType) || [];
+      if (respProperties && "properties" in respProperties && (respProperties == null ? void 0 : respProperties.properties)) {
+        if (Array.isArray(respProperties.properties)) {
+          properties = respProperties.properties;
+        } else {
+          rootProperty = respProperties.properties;
+        }
+      }
+      let definitionDescription = "";
+      if ("description" in respProperties) {
+        definitionDescription = respProperties.description || "";
+      }
+      variants.push({
+        title: code,
+        description: responseObject.description,
+        properties,
+        rootProperty,
+        meta: [
+          {
+            name: "status",
+            value: code || ""
+          },
+          {
+            name: "contentType",
+            value: contentType || ""
+          },
+          {
+            name: "definitionDescription",
+            value: definitionDescription
+          }
+        ],
+        symbolDef: definitionPropertyTypeDef(schema)
+      });
+    }
+  });
+  return {
+    title: "Response",
+    variants,
+    properties: []
+  };
+}
+function definitionPropertyTypeDef(schema) {
+  if (!schema) {
+    return;
+  }
+  let typeDef;
+  let oasSchema = schema;
+  if (oasSchema.type === "array") {
+    oasSchema = oasSchema.items;
+  }
+  if (oasSchema == null ? void 0 : oasSchema.__internal_getRefPath) {
+    const symbolId = oasSchema.__internal_getRefPath();
+    typeDef = {
+      id: symbolId
+    };
+  }
+  return typeDef;
+}
+function title(oapMethod, httpMethod, httpPath) {
+  const tit = (oapMethod == null ? void 0 : oapMethod.summary) || oapMethod.operationId || "";
+  if (tit) {
+    return tit;
+  }
+  if (!httpMethod || !httpPath) {
+    throw new Error("httpMethod and path are required to generate title");
+  }
+  return path2.join(httpMethod, cleanPath(httpPath));
+}
+function canonical(oapMethod, httpMethod, httpPath) {
+  let canon = oapMethod.operationId || slug2((oapMethod == null ? void 0 : oapMethod.summary) || "");
+  if (canon) {
+    return canon;
+  }
+  if (!httpMethod || !httpPath) {
+    throw new Error("httpMethod and path are required to generate canonical");
+  }
+  return path2.join(httpMethod, cleanPath(httpPath));
+}
+function getFirstTag(oapMethod) {
+  for (const tag of (oapMethod == null ? void 0 : oapMethod.tags) || []) {
+    return tag;
+  }
+  return "";
+}
+function cleanPath(httpPath) {
+  return httpPath.replace(/\{([^}]+)\}/g, "$1");
+}
+
+// src/converters/oas-schema.ts
+import path3 from "path";
+import Oas from "oas";
+
+// src/converters/oas-examples.ts
+import oasToSnippet from "@readme/oas-to-snippet";
+import { sample as openApiSampler } from "@xyd-js/openapi-sampler";
+
+// src/xdocs/index.ts
+function xDocsLanguages(oasDoc) {
+  const xDocs = getXDocs(oasDoc);
+  if (!xDocs) {
+    return null;
+  }
+  return (xDocs == null ? void 0 : xDocs.codeLanguages) ?? null;
+}
+function getXDocs(oasDoc) {
+  if (!("x-docs" in oasDoc)) {
+    return null;
+  }
+  return oasDoc["x-docs"];
+}
+
+// src/converters/oas-examples.ts
+var DEFAULT_CODE_LANGUAGES = ["shell", "javascript", "python", "go"];
+function oapExamples(oas, operation, visitedExamples) {
+  const exampleGroups = [
+    ...reqExamples(operation, oas, visitedExamples),
+    ...resBodyExmaples(operation, oas, visitedExamples)
+  ];
+  return exampleGroups;
+}
+function langFallback(lang) {
+  const langLower = lang.toLowerCase();
+  switch (langLower) {
+    case "curl": {
+      return "shell";
+    }
+  }
+  return langLower;
+}
+function reqExamples(operation, oas, vistedExamples) {
+  const exampleGroups = [];
+  const examples = [];
+  const tabs = [];
+  if (operation.schema["x-codeSamples"]) {
+    const codeSamples = operation.schema["x-codeSamples"];
+    const groupedByLabel = /* @__PURE__ */ new Map();
+    codeSamples.forEach((sample) => {
+      const label = sample.label || "default";
+      if (!groupedByLabel.has(label)) {
+        groupedByLabel.set(label, []);
+      }
+      groupedByLabel.get(label).push(sample);
+    });
+    groupedByLabel.forEach((samples, label) => {
+      const codeSampleTabs = samples.map((sample) => ({
+        title: sample.lang,
+        language: langFallback(sample.lang),
+        code: sample.source
+      }));
+      if (codeSampleTabs.length > 0) {
+        examples.push({
+          codeblock: {
+            title: label === "default" ? "Example request" : label,
+            tabs: codeSampleTabs
+          }
+        });
+      }
+    });
+    if (examples.length > 0) {
+      exampleGroups.push({
+        description: "Example request",
+        examples
+      });
+      return exampleGroups;
+    }
+  }
+  const paramData = operation.schema.parameters ? operation.schema.parameters.reduce((acc, param) => {
+    const location = param.in || "query";
+    if (!acc[location]) {
+      acc[location] = {};
+    }
+    let value = param.example;
+    if (!value && param.schema) {
+      value = openApiSampler(sanitizeSchema(param.schema));
+    }
+    if (value !== void 0) {
+      acc[location][param.name] = value;
+    }
+    return acc;
+  }, {}) : {};
+  let bodyData = {};
+  if (operation.schema.requestBody) {
+    const body = operation.schema.requestBody;
+    const contentTypes = Object.keys(body.content);
+    if (contentTypes.length > 0) {
+      const contentType = contentTypes[contentTypes.length - 1];
+      const content = body.content[contentType];
+      let schema = content == null ? void 0 : content.schema;
+      if (schema) {
+        schema = fixAllOfBug(schema);
+        schema = sanitizeSchema(schema);
+        let requestData;
+        if (content.examples) {
+          const requestExample = content.examples["request"];
+          if (requestExample && "value" in requestExample) {
+            requestData = requestExample.value;
+          }
+        }
+        if (!requestData) {
+          requestData = sampleFromSchema(schema);
+        }
+        if (contentType === "application/x-www-form-urlencoded") {
+          bodyData = { formData: requestData };
+        } else {
+          bodyData = { body: requestData };
+        }
+      }
+    }
+  }
+  const hasRequestBody = operation.schema.requestBody !== void 0;
+  const hasParameters = Object.keys(paramData).length > 0;
+  if (hasParameters || hasRequestBody || !hasRequestBody && !hasParameters) {
+    const langs = xDocsLanguages(operation.api) || DEFAULT_CODE_LANGUAGES;
+    langs.forEach((lang) => {
+      var _a, _b, _c;
+      let snippetOperation = operation;
+      const v = (_c = (_b = (_a = operation == null ? void 0 : operation.api) == null ? void 0 : _a.paths) == null ? void 0 : _b[operation == null ? void 0 : operation.path]) == null ? void 0 : _c[operation == null ? void 0 : operation.method];
+      if (v) {
+        snippetOperation = fixCircularReferences(v);
+      }
+      const { code } = oasToSnippet(oas, snippetOperation, {
+        ...paramData,
+        ...bodyData
+      }, null, lang);
+      tabs.push({
+        title: lang,
+        language: lang,
+        code: code || ""
+      });
+    });
+    if (tabs.length > 0) {
+      examples.push({
+        codeblock: {
+          tabs
+        }
+      });
+    }
+    if (examples.length > 0) {
+      exampleGroups.push({
+        description: "Example request",
+        examples
+      });
+    }
+  }
+  return exampleGroups;
+}
+function resBodyExmaples(operation, oas, vistedExamples) {
+  const exampleGroups = [];
+  if (operation.schema.responses) {
+    const responses = operation.schema.responses;
+    const examples = [];
+    Object.entries(responses).forEach(([status, r]) => {
+      const response = r;
+      if (!response.content) {
+        return;
+      }
+      const contentTypes = Object.keys(response.content);
+      if (contentTypes.length === 0) {
+        return;
+      }
+      const tabs = [];
+      for (const contentType of contentTypes) {
+        const content = response.content[contentType];
+        const schema = content == null ? void 0 : content.schema;
+        if (!schema) {
+          continue;
+        }
+        let responseData;
+        if (content.examples) {
+          const responseExample = content.examples["response"];
+          if (responseExample && "value" in responseExample) {
+            responseData = responseExample.value;
+          } else {
+            const namedExamples = [];
+            const exampleNames = Object.keys(content.examples);
+            exampleNames.forEach((exampleName) => {
+              var _a;
+              const data = (_a = content == null ? void 0 : content.examples) == null ? void 0 : _a[exampleName];
+              if (!data || !("value" in data) || typeof data.value != "object") {
+                return;
+              }
+              namedExamples.push({
+                description: "",
+                codeblock: {
+                  title: exampleName,
+                  tabs: [
+                    {
+                      title: "application/json",
+                      // TODO: support multiple types
+                      language: "json",
+                      code: JSON.stringify(data.value, null, 2) || ""
+                    }
+                  ]
+                }
+              });
+            });
+            if (namedExamples.length === 1) {
+              const firstCodeblock = namedExamples[0].codeblock;
+              tabs.push(
+                ...firstCodeblock.tabs.map((tab) => ({
+                  ...tab,
+                  title: contentType
+                }))
+              );
+            } else {
+              exampleGroups.push({
+                description: "",
+                examples: namedExamples
+              });
+            }
+            continue;
+          }
+        } else if (content.example) {
+          responseData = content.example;
+        }
+        if (!responseData) {
+          responseData = sampleFromSchema(schema);
+        }
+        let extension = "text";
+        switch (contentType) {
+          case "application/json":
+          case "application/problem+json":
+          case "application/vnd.api+json": {
+            extension = "json";
+            break;
+          }
+          case "application/xml":
+          case "text/xml":
+          case "application/problem+xml": {
+            extension = "xml";
+            break;
+          }
+        }
+        tabs.push({
+          title: contentType,
+          language: extension,
+          code: JSON.stringify(responseData, null, 2) || ""
+        });
+      }
+      if (tabs.length > 0) {
+        examples.push({
+          codeblock: {
+            title: status,
+            tabs
+          }
+        });
+      }
+    });
+    if (examples.length > 0) {
+      exampleGroups.push({
+        description: "Example response",
+        examples
+      });
+    }
+  }
+  return exampleGroups;
+}
+function fixAllOfBug(schema) {
+  const modifiedSchema = { ...schema };
+  if (schema == null ? void 0 : schema.allOf) {
+    schema.allOf.forEach((prop, i) => {
+      var _a;
+      const propObj = prop;
+      if ("properties" in propObj && !propObj["properties"]) {
+        (_a = modifiedSchema.allOf) == null ? true : delete _a[i];
+      }
+    });
+  }
+  return modifiedSchema;
+}
+function sanitizeSchema(schema, vistedExamples = /* @__PURE__ */ new Map(), parent) {
+  if (vistedExamples.has(schema)) {
+    const cached = vistedExamples.get(schema);
+    if (typeof cached === "object") {
+      return JSON.parse(JSON.stringify(cached));
+    }
+    return cached;
+  }
+  if (parent) {
+    vistedExamples.set(schema, parent);
+  }
+  if (!schema || typeof schema !== "object") {
+    vistedExamples.set(schema, schema);
+    return schema;
+  }
+  if (Array.isArray(schema)) {
+    const v = schema.map((item) => sanitizeSchema(item, vistedExamples));
+    vistedExamples.set(schema, v);
+    return v;
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "__UNSAFE_refPath") {
+      continue;
+    }
+    if (!BUILT_IN_PROPERTIES[key]) {
+      cleaned[key] = sanitizeSchema(value, vistedExamples, cleaned);
+    }
+  }
+  vistedExamples.set(schema, cleaned);
+  return cleaned;
+}
+function sampleFromSchema(schema) {
+  var _a, _b;
+  let jsonSchema = null;
+  let multiSpec = null;
+  if ((_a = schema.oneOf) == null ? void 0 : _a.length) {
+    multiSpec = schema.oneOf;
+  } else if ((_b = schema.anyOf) == null ? void 0 : _b.length) {
+    multiSpec = schema.anyOf;
+  }
+  if (multiSpec == null ? void 0 : multiSpec.length) {
+    for (let i = multiSpec.length - 1; i >= 0; i--) {
+      const spec = multiSpec[i];
+      const sanitized = sanitizeSchema(spec);
+      if (!sanitized) {
+        continue;
+      }
+      jsonSchema = sanitized;
+      if (!(jsonSchema == null ? void 0 : jsonSchema.properties)) {
+        continue;
+      }
+      break;
+    }
+  } else {
+    jsonSchema = sanitizeSchema(schema);
+  }
+  if (jsonSchema) {
+    return openApiSampler(jsonSchema);
+  }
+  return null;
+}
+function fixCircularReferences(schema, visited = /* @__PURE__ */ new WeakMap()) {
+  if (!schema || typeof schema !== "object") {
+    return schema;
+  }
+  if (visited.has(schema)) {
+    return visited.get(schema);
+  }
+  if (schema.__UNSAFE_circular) {
+    const simplified = {
+      type: "object",
+      description: "Circular reference detected - schema simplified"
+    };
+    visited.set(schema, simplified);
+    return simplified;
+  }
+  if (Array.isArray(schema)) {
+    const result = schema.map((item) => fixCircularReferences(item, visited));
+    visited.set(schema, result);
+    return result;
+  }
+  const fixedSchema = {};
+  visited.set(schema, fixedSchema);
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "__UNSAFE_circular" || key === "__UNSAFE_refPath") {
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      fixedSchema[key] = fixCircularReferences(value, visited);
+    } else {
+      fixedSchema[key] = value;
+    }
+  }
+  return fixedSchema;
+}
+
+// src/converters/oas-componentSchemas.ts
+import {
+  ReferenceType as ReferenceType2
+} from "@xyd-js/uniform";
+function schemaComponentsToUniformReferences(openapi, options) {
+  var _a;
+  const references = [];
+  if (!((_a = openapi.components) == null ? void 0 : _a.schemas)) {
+    return references;
+  }
+  for (const [componentSchemaName, componentSchema] of Object.entries(openapi.components.schemas)) {
+    if ((options == null ? void 0 : options.regions) && options.regions.length > 0) {
+      if (!options.regions.some((region) => region === "/components/schemas/" + componentSchemaName)) {
+        continue;
+      }
+    }
+    if ("$ref" in componentSchema) {
+      console.warn(`Skipping reference object: ${componentSchemaName}`);
+      continue;
+    }
+    let properties = [];
+    let rootProperty = void 0;
+    const respProperties = schemaObjectToUniformDefinitionProperties(componentSchema, false) || [];
+    if (Array.isArray(respProperties)) {
+      properties = respProperties;
+    } else {
+      rootProperty = respProperties;
+    }
+    const symbolDef = definitionPropertyTypeDef2(componentSchema);
+    const definition = {
+      title: componentSchemaName,
+      properties,
+      rootProperty,
+      meta: [],
+      symbolDef
+    };
+    const reference = {
+      title: componentSchemaName,
+      description: componentSchema.description || "",
+      canonical: `objects/${componentSchemaName}`,
+      definitions: [definition],
+      examples: {
+        groups: createSchemaExampleGroup(componentSchema)
+      },
+      type: ReferenceType2.REST_COMPONENT_SCHEMA,
+      context: {
+        componentSchema: componentSchemaName,
+        group: ["Objects"]
+      }
+    };
+    reference.__UNSAFE_selector = function __UNSAFE_selector(selector) {
+      switch (selector) {
+        case "[schema]": {
+          return openapi;
+        }
+        case "[component]": {
+          return componentSchema;
+        }
+        default:
+          return null;
+      }
+    };
+    references.push(reference);
+  }
+  return references;
+}
+function createSchemaExampleGroup(schema, map) {
+  const example = generateSchemaExample(schema);
+  if (!example) {
+    return [];
+  }
+  const tabs = [{
+    title: "json",
+    language: "json",
+    code: JSON.stringify(example, null, 2)
+  }];
+  return [{
+    description: "Example",
+    examples: [{
+      codeblock: {
+        tabs
+      }
+    }]
+  }];
+}
+function definitionPropertyTypeDef2(schema) {
+  if (!schema) {
+    return;
+  }
+  let typeDef;
+  let oasSchema = schema;
+  if (oasSchema.type === "array") {
+    oasSchema = oasSchema.items;
+  }
+  if (oasSchema == null ? void 0 : oasSchema.__internal_getRefPath) {
+    const symbolId = oasSchema.__internal_getRefPath();
+    typeDef = {
+      id: symbolId
+    };
+  }
+  return typeDef;
+}
+function generateSchemaExample(schema, visitedExample, parent) {
+  if (!schema) {
+    return null;
+  }
+  if (!visitedExample) {
+    visitedExample = /* @__PURE__ */ new Map();
+  }
+  const cached = visitedExample.get(schema);
+  if (cached) {
+    return JSON.parse(JSON.stringify(cached));
+  }
+  if (parent) {
+    visitedExample.set(schema, parent);
+  }
+  if ("examples" in schema && Array.isArray(schema.examples)) {
+    const v = schema.examples[0];
+    visitedExample.set(schema, v);
+    return v;
+  }
+  if ("example" in schema && schema.example !== void 0) {
+    const v = schema.example;
+    visitedExample.set(schema, v);
+    return v;
+  }
+  if (schema.type === "object" && schema.properties) {
+    const result = {};
+    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+      result[propName] = generateSchemaExample(propSchema, visitedExample, result);
+    }
+    visitedExample.set(schema, result);
+    return result;
+  }
+  if (schema.type === "array" && schema.items) {
+    const itemExample = generateSchemaExample(schema.items, visitedExample);
+    const v = itemExample ? [itemExample] : [];
+    visitedExample.set(schema, v);
+    return v;
+  }
+  switch (schema.type) {
+    case "string":
+      return "";
+    case "number":
+    case "integer":
+      return 0;
+    case "boolean":
+      return false;
+    default:
+      return null;
+  }
+}
+
+// src/converters/oas-schema.ts
+function oapSchemaToReferences(schema, options) {
+  var _a, _b;
+  if (!schema) {
+    return [];
+  }
+  const references = [];
+  const oas = new Oas(schema);
+  const server = ((_b = (_a = schema.servers) == null ? void 0 : _a[0]) == null ? void 0 : _b.url) || "";
+  Object.entries(schema.paths).forEach(([endpointPath, oapPath]) => {
+    SUPPORTED_HTTP_METHODS.forEach((eachMethod) => {
+      var _a2, _b2, _c, _d;
+      const httpMethod = eachMethod.toLowerCase();
+      const found = httpMethodToUniformMethod(httpMethod);
+      if (!found) {
+        console.warn(`Unsupported method: ${httpMethod} for path: ${endpointPath}`);
+        return;
+      }
+      if ((options == null ? void 0 : options.regions) && options.regions.length > 0) {
+        const regionKey = `${eachMethod.toUpperCase()} ${endpointPath}`;
+        if (!options.regions.some((region) => region === regionKey)) {
+          return;
+        }
+      }
+      const reference = oapPathToReference(
+        schema,
+        httpMethod,
+        endpointPath,
+        oapPath
+      );
+      if (reference) {
+        const ctx = reference.context;
+        ctx.path = endpointPath;
+        ctx.fullPath = path3.join(server, endpointPath);
+        const operation = oas.operation(endpointPath, httpMethod);
+        reference.examples.groups = oapExamples(oas, operation);
+        const scopes = [];
+        const oapMethod = oapPath == null ? void 0 : oapPath[httpMethod];
+        if ((_a2 = schema == null ? void 0 : schema.security) == null ? void 0 : _a2.length) {
+          for (const security of schema.security) {
+            for (const securityKey of Object.keys(security)) {
+              if (securityKey === "oauth2" || securityKey === "OAuth2") {
+                const securityScopes = security[securityKey];
+                if (Array.isArray(securityScopes)) {
+                  scopes.push(...securityScopes);
+                }
+              }
+            }
+          }
+        }
+        if (oapMethod == null ? void 0 : oapMethod.security) {
+          if (!((_b2 = oapMethod == null ? void 0 : oapMethod.security) == null ? void 0 : _b2.length)) {
+            scopes.length = 0;
+          }
+          for (const security of oapMethod.security) {
+            for (const securityKey of Object.keys(security)) {
+              const securityScheme = (_d = (_c = schema == null ? void 0 : schema.components) == null ? void 0 : _c.securitySchemes) == null ? void 0 : _d[securityKey];
+              if (securityScheme && "type" in securityScheme && securityScheme.type === "oauth2") {
+                const methodScopes = security[securityKey];
+                if (Array.isArray(methodScopes)) {
+                  scopes.push(...methodScopes);
+                }
+              }
+            }
+          }
+        }
+        ctx.scopes = scopes;
+        references.push(reference);
+      }
+    });
+  });
+  const schemas = schemaComponentsToUniformReferences(
+    schema,
+    options
+  );
+  references.push(...schemas);
+  const tags = oas.getTags();
+  sortReferencesByTags(references, tags);
+  references.__internal_options = () => options;
+  return references;
+}
+function sortReferencesByTags(references, tags) {
+  return references.sort((prev, next) => {
+    var _a, _b;
+    const aTags = ((_a = prev.context) == null ? void 0 : _a.group) || [];
+    const bTags = ((_b = next.context) == null ? void 0 : _b.group) || [];
+    for (const tag of tags) {
+      const aIndex = aTags.indexOf(tag);
+      const bIndex = bTags.indexOf(tag);
+      if (aIndex !== -1 && bIndex !== -1) {
+        return aIndex - bIndex;
+      }
+      if (aIndex !== -1) return -1;
+      if (bIndex !== -1) return 1;
+    }
+    return (aTags[0] || "").localeCompare(bTags[0] || "");
+  });
+}
+
+// src/xdocs/pluginSidebar.ts
+function uniformPluginXDocsSidebar({
+  references,
+  defer
+}) {
+  let schema;
+  const refByOperationId = {};
+  const refByComponentSchema = {};
+  defer(() => {
+    var _a;
+    if (typeof references.__internal_options === "function") {
+      const options = references.__internal_options();
+      if ((_a = options == null ? void 0 : options.regions) == null ? void 0 : _a.length) {
+        return {};
+      }
+    }
+    const output = [];
+    if (!schema) {
+      return {};
+    }
+    const xDocs = schema["x-docs"];
+    if (!(xDocs == null ? void 0 : xDocs.sidebar)) {
+      return {};
+    }
+    const navigationMap = {};
+    for (let i = 0; i < xDocs.sidebar.length; i++) {
+      const navGroup = xDocs.sidebar[i];
+      if (!navGroup) {
+        continue;
+      }
+      const uniqueKey = `${navGroup.group}-${i}`;
+      navigationMap[uniqueKey] = {
+        id: navGroup.group,
+        title: navGroup.group,
+        beta: false,
+        index: i
+      };
+    }
+    for (let i = 0; i < xDocs.sidebar.length; i++) {
+      const group = xDocs.sidebar[i];
+      const uniqueKey = `${group.group}-${i}`;
+      const navGroup = navigationMap[uniqueKey];
+      if (!navGroup) {
+        console.warn(`No navigation group found for group: ${group.group}`);
+        continue;
+      }
+      if (!Array.isArray(group.pages)) {
+        continue;
+      }
+      processGroupPages(xDocs, group.pages, [group.group], navGroup, output);
+    }
+    if (Array.isArray(references)) {
+      references.length = 0;
+      references.push(...output);
+    } else {
+      references = output[0] || references;
+    }
+    return {};
+  });
+  function processGroupPages(xDocs, pages, groupPath, navGroup, output, parentPath) {
+    for (const page of pages) {
+      if ("pages" in page && Array.isArray(page.pages)) {
+        processGroupPages(xDocs, page.pages, [...groupPath, page.group], navGroup, output, page.path);
+      } else if ("type" in page && "key" in page) {
+        processPage(xDocs, page, groupPath, navGroup, output, parentPath);
+      }
+    }
+  }
+  function processPage(xDocs, page, groupPath, navGroup, output, parentPath) {
+    let uniformRef;
+    switch (page.type) {
+      case "endpoint": {
+        const operationRef = refByOperationId[page.key];
+        if (!operationRef) {
+          console.warn(`No operation found for key: ${page.key} in group ${groupPath.join("/")}`);
+          return;
+        }
+        uniformRef = operationRef;
+        break;
+      }
+      case "object": {
+        const componentRef = refByComponentSchema[page.key];
+        if (!componentRef) {
+          console.warn(`No component schema found for key: ${page.key} in group ${groupPath.join("/")}`);
+          return;
+        }
+        const selector = componentRef.__UNSAFE_selector;
+        if (!selector || typeof selector !== "function") {
+          return;
+        }
+        const component = selector("[component]");
+        if (!component) {
+          console.warn(`No component schema found for key: ${page.key} in group ${groupPath.join("/")}`);
+          return;
+        }
+        let componentMeta;
+        if (component.allOf) {
+          let found = false;
+          for (const item of component.allOf) {
+            const docsMeta = item["x-docs"];
+            if (docsMeta && found) {
+              console.warn(`Multiple x-docs found in allOf for component schema: ${page.key} in group ${groupPath.join("/")}`);
+            }
+            if (docsMeta) {
+              found = true;
+              componentMeta = docsMeta;
+              break;
+            }
+          }
+          if (!found) {
+            console.warn(`No x-docs found in allOf for component schema: ${page.key} in group ${groupPath.join("/")}`);
+            return;
+          }
+        } else {
+          const docsMeta = component["x-docs"];
+          if (docsMeta) {
+            componentMeta = docsMeta;
+          }
+        }
+        uniformRef = componentRef;
+        if (!componentMeta) {
+          break;
+        }
+        componentRef.title = componentMeta.name || componentRef.title;
+        if (componentMeta.example) {
+          const exampleGroups = oasXDocsExamples(componentMeta.example);
+          uniformRef.examples = {
+            groups: exampleGroups
+          };
+        }
+        break;
+      }
+      default: {
+        console.warn(`Unknown page type: ${page.type} in group ${groupPath.join("/")}`);
+        return;
+      }
+    }
+    if (!uniformRef) {
+      return;
+    }
+    if (xDocs.sidebarPathStrategy === "inherit") {
+      const ctx = uniformRef.context;
+      let firstPart = "";
+      if (parentPath) {
+        firstPart = parentPath;
+      } else {
+        firstPart = (ctx == null ? void 0 : ctx.path) || "";
+      }
+      const canonical2 = joinPaths(firstPart || "", page.path);
+      if (canonical2) {
+        uniformRef.canonical = canonical2;
+      }
+    } else if (page.path) {
+      uniformRef.canonical = joinPaths(parentPath, page.path);
+    } else if (parentPath) {
+      uniformRef.canonical = parentPath;
+    }
+    if (!uniformRef.context) {
+      uniformRef.context = {};
+    }
+    uniformRef.context.group = groupPath;
+    output.push(uniformRef);
+  }
+  return function pluginXDocsSidebarInner(ref) {
+    var _a, _b;
+    const selector = ref.__UNSAFE_selector;
+    if (!selector || typeof selector !== "function") {
+      return;
+    }
+    const oapSchema = selector("[schema]");
+    if (!oapSchema) {
+      return;
+    }
+    schema = oapSchema;
+    const ctx = ref.context;
+    if (ctx == null ? void 0 : ctx.componentSchema) {
+      refByComponentSchema[ctx.componentSchema] = ref;
+    }
+    const methodPath = selector("[method] [path]");
+    if (!methodPath) {
+      return;
+    }
+    const oapMethod = selector("[method]");
+    if (!oapMethod) {
+      return;
+    }
+    const operationId = methodPath.operationId;
+    if (operationId) {
+      refByOperationId[operationId] = ref;
+    }
+    const methodId = (((_a = oapMethod == null ? void 0 : oapMethod.httpMethod) == null ? void 0 : _a.toUpperCase()) + " " + (oapMethod == null ? void 0 : oapMethod.path) || "").trim();
+    if (methodId) {
+      refByOperationId[methodId] = ref;
+    }
+    const meta = methodPath["x-docs"];
+    if (!meta) {
+      return;
+    }
+    if (meta.name) {
+      ref.title = meta.name;
+    }
+    if (meta.group) {
+      if (ref.context) {
+        ref.context.group = [meta.group];
+      }
+    }
+    if (!ref.description) {
+      ref.description = methodPath.summary || "";
+    }
+    if (meta.examples) {
+      const exampleGroups = oasXDocsExamples(meta.examples);
+      ref.examples = {
+        groups: exampleGroups
+      };
+    }
+    if (meta.returns) {
+      if ((_b = ref.definitions) == null ? void 0 : _b.length) {
+        ref.definitions[ref.definitions.length - 1] = {
+          title: ref.definitions[ref.definitions.length - 1].title,
+          description: meta.returns,
+          properties: []
+        };
+      } else {
+        ref.definitions = [
+          {
+            title: "Response",
+            description: meta.returns,
+            properties: []
+          }
+        ];
+      }
+    }
+  };
+}
+function oasXDocsExamples(examples) {
+  const groups = [];
+  if (examples) {
+    if (Array.isArray(examples)) {
+      const requestExamples = [];
+      examples.forEach((example) => {
+        if (example.request) {
+          const tabs = [];
+          if (typeof example.request === "string") {
+            tabs.push({
+              title: "",
+              language: "json",
+              code: example.request
+            });
+          } else {
+            for (let lang of Object.keys(example.request)) {
+              const code = example.request[lang] || "";
+              const language = lang === "curl" ? "bash" : lang === "node.js" ? "js" : lang;
+              tabs.push({
+                title: lang,
+                language,
+                code
+              });
+            }
+          }
+          if (tabs.length > 0) {
+            requestExamples.push({
+              description: example.title || "",
+              codeblock: {
+                title: example.title || "",
+                tabs
+              }
+            });
+          }
+        }
+      });
+      if (requestExamples.length > 0) {
+        groups.push({
+          description: "Example request",
+          examples: requestExamples
+        });
+      }
+      const responseExamples = [];
+      examples.forEach((example) => {
+        if (example.response) {
+          const tabs = [];
+          if (typeof example.response === "string") {
+            tabs.push({
+              title: "",
+              language: "json",
+              code: example.response
+            });
+          } else {
+            for (let lang of Object.keys(example.response)) {
+              const code = example.response[lang] || "";
+              const language = lang === "curl" ? "bash" : lang === "node.js" ? "js" : lang;
+              tabs.push({
+                title: lang,
+                language,
+                code
+              });
+            }
+          }
+          if (tabs.length > 0) {
+            responseExamples.push({
+              description: example.title || "",
+              codeblock: {
+                title: example.title || "",
+                tabs
+              }
+            });
+          }
+        }
+      });
+      if (responseExamples.length > 0) {
+        groups.push({
+          description: "Example response",
+          examples: responseExamples
+        });
+      }
+    } else {
+      if (typeof examples === "string") {
+        groups.push({
+          description: "Example",
+          examples: [
+            {
+              description: "",
+              codeblock: {
+                tabs: [
+                  {
+                    title: "",
+                    language: "json",
+                    code: examples
+                  }
+                ]
+              }
+            }
+          ]
+        });
+      } else {
+        if (examples.request) {
+          const tabs = [];
+          if (typeof examples.request === "string") {
+            tabs.push({
+              title: "",
+              language: "json",
+              code: examples.request || ""
+            });
+          } else {
+            for (let lang of Object.keys(examples.request)) {
+              const code = examples.request[lang] || "";
+              switch (lang) {
+                case "curl":
+                  lang = "bash";
+                  break;
+                case "node.js":
+                  lang = "js";
+                  break;
+                default:
+                  break;
+              }
+              tabs.push({
+                title: lang,
+                language: lang,
+                code
+              });
+            }
+          }
+          groups.push({
+            description: "Example request",
+            examples: [
+              {
+                description: "",
+                codeblock: {
+                  tabs
+                }
+              }
+            ]
+          });
+        }
+        if (examples.response) {
+          const tabs = [];
+          if (typeof examples.response === "string") {
+            tabs.push({
+              title: "",
+              language: "json",
+              code: examples.response || ""
+            });
+          } else {
+            for (let lang of Object.keys(examples.response)) {
+              const code = examples.response[lang] || "";
+              switch (lang) {
+                case "curl":
+                  lang = "bash";
+                  break;
+                case "node.js":
+                  lang = "js";
+                  break;
+                default:
+                  break;
+              }
+              tabs.push({
+                title: lang,
+                language: lang,
+                code
+              });
+            }
+          }
+          groups.push({
+            description: "Example response",
+            examples: [
+              {
+                description: "",
+                codeblock: {
+                  tabs
+                }
+              }
+            ]
+          });
+        }
+      }
+    }
+  }
+  return groups;
+}
+function joinPaths(...paths) {
+  return paths.filter(Boolean).map((path4) => {
+    path4 = path4.replace(/^\/+|\/+$/g, "");
+    return path4 ? `/${path4}` : "";
+  }).join("").replace(/\/+/g, "/").replace(/\/\{[^}]+\}/g, "").replace(/\/:[^/]+/g, "");
+}
+export {
+  deferencedOpenAPI,
+  getXDocs,
+  oapResponseOperationToUniformDefinition,
+  oapSchemaToReferences,
+  uniformPluginXDocsSidebar
+};
+//# sourceMappingURL=index.js.map