@cparra/apexdocs 3.1.1 → 3.2.0

package/dist/logger-Caah2QkF.js

@@ -0,0 +1,3655 @@
+'use strict';
+
+var _function = require('fp-ts/function');
+var TE = require('fp-ts/TaskEither');
+var E = require('fp-ts/Either');
+var yaml = require('js-yaml');
+var path = require('path');
+var T = require('fp-ts/Task');
+var A = require('fp-ts/lib/Array');
+var apexReflection = require('@cparra/apex-reflection');
+var O = require('fp-ts/Option');
+var fastXmlParser = require('fast-xml-parser');
+var Handlebars = require('handlebars');
+var boolean = require('fp-ts/boolean');
+var fs = require('fs');
+var TE$1 = require('fp-ts/lib/TaskEither');
+var minimatch = require('minimatch');
+var chalk = require('chalk');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var TE__namespace = /*#__PURE__*/_interopNamespaceDefault(TE);
+var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
+var yaml__namespace = /*#__PURE__*/_interopNamespaceDefault(yaml);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var T__namespace = /*#__PURE__*/_interopNamespaceDefault(T);
+var A__namespace = /*#__PURE__*/_interopNamespaceDefault(A);
+var O__namespace = /*#__PURE__*/_interopNamespaceDefault(O);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var TE__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(TE$1);
+
+function apply(fn, ...front) {
+  return (...tailArgs) => fn(...front, ...tailArgs);
+}
+
+function defaultGetEmailByReference(email) {
+  return {
+    __type: "link",
+    title: email,
+    url: `mailto:${email}`
+  };
+}
+function replaceInlineReferences(text, linkReplacer, emailReplacer = defaultGetEmailByReference) {
+  const inlineLinks = apply(replaceInlineLinks, linkReplacer);
+  const inlineEmails = apply(replaceInlineEmails, emailReplacer);
+  return _function.pipe(inlineCode$1([text]), inlineLinks, inlineEmails);
+}
+function inlineCode$1(renderableContents) {
+  return renderableContents.flatMap((renderableContent) => inlineCodeContent(renderableContent));
+}
+function inlineCodeContent(renderableContent) {
+  if (typeof renderableContent !== "string") {
+    return [renderableContent];
+  }
+  function inlineCodeLink(text2) {
+    return {
+      __type: "inline-code",
+      content: text2
+    };
+  }
+  const text = renderableContent;
+  const codeFormatRegEx = "`([^`]*)`";
+  const matches = match(codeFormatRegEx, text);
+  return createRenderableContents(matches, text, inlineCodeLink);
+}
+function replaceInlineLinks(getLinkByTypeName, renderableContents) {
+  return renderableContents.flatMap((renderableContent) => inlineLinkContent(renderableContent, getLinkByTypeName));
+}
+function inlineLinkContent(renderableContent, getLinkByTypeName) {
+  if (typeof renderableContent !== "string") {
+    return [renderableContent];
+  }
+  const text = renderableContent;
+  const linkFormatRegEx = "{@link (.*?)}|<<([^>]+)>>";
+  const matches = match(linkFormatRegEx, text);
+  return createRenderableContents(matches, text, getLinkByTypeName);
+}
+function replaceInlineEmails(getLinkByTypeName, renderableContents) {
+  return renderableContents.flatMap((renderableContent) => inlineEmailContent(renderableContent, getLinkByTypeName));
+}
+function inlineEmailContent(renderableContent, getLinkByTypeName) {
+  if (typeof renderableContent !== "string") {
+    return [renderableContent];
+  }
+  const text = renderableContent;
+  const linkFormatRegEx = "{@email (.*?)}";
+  const matches = match(linkFormatRegEx, text);
+  return createRenderableContents(matches, text, getLinkByTypeName);
+}
+function match(regex, text) {
+  const expression = new RegExp(regex, "gi");
+  let match2;
+  const matches = [];
+  do {
+    match2 = expression.exec(text);
+    if (match2) {
+      matches.push(match2);
+    }
+  } while (match2);
+  return matches;
+}
+function createRenderableContents(matches, text, linker) {
+  if (matches.length === 0) {
+    return [text];
+  }
+  const result = [];
+  let lastIndex = 0;
+  for (const match2 of matches) {
+    const index = match2.index;
+    const length = match2[0].length;
+    const capturedGroup = match2.slice(1).find((group) => group);
+    if (!capturedGroup) {
+      continue;
+    }
+    result.push(text.slice(lastIndex, index));
+    result.push(linker(capturedGroup));
+    lastIndex = index + length;
+  }
+  if (lastIndex < text.length) {
+    result.push(text.slice(lastIndex));
+  }
+  return result;
+}
+
+function isEmptyLine(content) {
+  return Object.keys(content).includes("__type") && content.__type === "empty-line";
+}
+function isCodeBlock(content) {
+  return Object.keys(content).includes("__type") && content.__type === "code-block";
+}
+function isInlineCode(content) {
+  return Object.keys(content).includes("__type") && content.__type === "inline-code";
+}
+
+var __defProp$h = Object.defineProperty;
+var __defProps$h = Object.defineProperties;
+var __getOwnPropDescs$h = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
+var __hasOwnProp$h = Object.prototype.hasOwnProperty;
+var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$h = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$h.call(b, prop))
+      __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b)) {
+      if (__propIsEnum$h.call(b, prop))
+        __defNormalProp$h(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
+function adaptDescribable(describable, linkGenerator) {
+  return {
+    description: describableToRenderableContent(describable, linkGenerator)
+  };
+}
+function describableToRenderableContent(describable, linkGenerator) {
+  if (!describable) {
+    return;
+  }
+  let content = [];
+  for (let i = 0; i < describable.length; i++) {
+    const line = describable[i];
+    const codeBlockMatch = line.match(/^```([a-zA-Z]*)$/);
+    if (codeBlockMatch) {
+      const language = codeBlockMatch[1] || "apex";
+      const codeBlockLines = [];
+      i++;
+      while (i < describable.length) {
+        const currentLine = describable[i];
+        if (currentLine.trim() === "```") {
+          break;
+        }
+        codeBlockLines.push(currentLine);
+        i++;
+      }
+      content = [
+        ...content,
+        {
+          __type: "code-block",
+          language,
+          content: codeBlockLines
+        },
+        { __type: "empty-line" }
+      ];
+      continue;
+    }
+    content = [
+      ...content,
+      ...replaceInlineReferences(line, linkGenerator),
+      {
+        __type: "empty-line"
+      }
+    ];
+  }
+  return content.filter((line, index, lines) => !(isEmptyLine(line) && index === lines.length - 1));
+}
+function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
+  var _a, _b, _c;
+  function extractCustomTags(type) {
+    var _a2, _b2;
+    const baseTags = ["description", "group", "author", "date", "see", "example", "throws", "exception"];
+    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$h(__spreadValues$h({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
+      name: currentAnnotation.name
+    }))) != null ? _b2 : [];
+  }
+  function extractAnnotationBody(type, annotationName) {
+    var _a2, _b2;
+    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.find(
+      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName
+    )) == null ? void 0 : _b2.body;
+  }
+  function extractSeeAnnotations(type) {
+    var _a2, _b2;
+    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === "see").map((currentAnnotation) => currentAnnotation.body)) != null ? _b2 : [];
+  }
+  return __spreadProps$h(__spreadValues$h({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+    annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
+    customTags: extractCustomTags(documentable),
+    example: {
+      headingLevel: subHeadingLevel,
+      heading: "Example",
+      value: describableToRenderableContent((_c = (_b = documentable.docComment) == null ? void 0 : _b.exampleAnnotation) == null ? void 0 : _c.bodyLines, linkGenerator)
+    },
+    group: extractAnnotationBody(documentable, "group"),
+    author: extractAnnotationBody(documentable, "author"),
+    date: extractAnnotationBody(documentable, "date"),
+    sees: extractSeeAnnotations(documentable).map(linkGenerator)
+  });
+}
+
+var __defProp$g = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
+function adaptMethod(method, linkGenerator, baseHeadingLevel) {
+  var _a, _b, _c;
+  function buildTitle(method2) {
+    const { name, parameters } = method2;
+    const parametersString = parameters.map((param) => param.name).join(", ");
+    return `${name}(${parametersString})`;
+  }
+  function buildSignature(method2) {
+    const { access_modifier, typeReference, name, memberModifiers } = method2;
+    const parameters = method2.parameters.map((param) => `${param.typeReference.rawDeclaration} ${param.name}`).join(", ");
+    const members = memberModifiers.length > 0 ? `${memberModifiers.join(" ")} ` : "";
+    return {
+      __type: "code-block",
+      language: "apex",
+      content: [`${access_modifier} ${members}${typeReference.rawDeclaration} ${name}(${parameters})`]
+    };
+  }
+  return {
+    headingLevel: baseHeadingLevel,
+    doc: adaptDocumentable(method, linkGenerator, baseHeadingLevel + 1),
+    heading: buildTitle(method),
+    signature: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Signature",
+      value: buildSignature(method)
+    },
+    returnType: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Return Type",
+      value: __spreadProps$g(__spreadValues$g({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
+        type: linkGenerator(method.typeReference.rawDeclaration)
+      })
+    },
+    throws: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Throws",
+      value: (_c = method.docComment) == null ? void 0 : _c.throwsAnnotations.map((thrown) => mapThrows(thrown, linkGenerator))
+    },
+    parameters: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Parameters",
+      value: method.parameters.map((param) => mapParameters(method, param, linkGenerator))
+    },
+    inherited: method.inherited
+  };
+}
+function adaptConstructor(typeName, constructor, linkGenerator, baseHeadingLevel) {
+  var _a;
+  function buildTitle(name, constructor2) {
+    const { parameters } = constructor2;
+    const parametersString = parameters.map((param) => param.name).join(", ");
+    return `${name}(${parametersString})`;
+  }
+  function buildSignature(name, constructor2) {
+    const { access_modifier } = constructor2;
+    const parameters = constructor2.parameters.map((param) => `${param.typeReference.rawDeclaration} ${param.name}`).join(", ");
+    return {
+      __type: "code-block",
+      language: "apex",
+      content: [`${access_modifier} ${name}(${parameters})`]
+    };
+  }
+  return {
+    doc: adaptDocumentable(constructor, linkGenerator, baseHeadingLevel + 1),
+    headingLevel: baseHeadingLevel,
+    heading: buildTitle(typeName, constructor),
+    signature: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Signature",
+      value: buildSignature(typeName, constructor)
+    },
+    parameters: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Parameters",
+      value: constructor.parameters.map((param) => mapParameters(constructor, param, linkGenerator))
+    },
+    throws: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Throws",
+      value: (_a = constructor.docComment) == null ? void 0 : _a.throwsAnnotations.map((thrown) => mapThrows(thrown, linkGenerator))
+    }
+  };
+}
+function mapParameters(documentable, param, linkGenerator) {
+  var _a;
+  const paramAnnotation = (_a = documentable.docComment) == null ? void 0 : _a.paramAnnotations.find(
+    (pa) => pa.paramName.toLowerCase() === param.name.toLowerCase()
+  );
+  return __spreadProps$g(__spreadValues$g({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
+    name: param.name,
+    type: linkGenerator(param.typeReference.rawDeclaration)
+  });
+}
+function mapThrows(thrown, linkGenerator) {
+  return __spreadProps$g(__spreadValues$g({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
+    type: linkGenerator(thrown.exceptionName)
+  });
+}
+
+function adaptFieldOrProperty(field, linkGenerator, baseHeadingLevel) {
+  function buildSignature() {
+    const { access_modifier, name } = field;
+    const memberModifiers = field.memberModifiers.join(" ");
+    const codeContents = `${access_modifier} ${memberModifiers} ${name}`.replace(/ {2}/g, " ");
+    return {
+      __type: "code-block",
+      language: "apex",
+      content: [codeContents]
+    };
+  }
+  return {
+    headingLevel: baseHeadingLevel,
+    doc: adaptDocumentable(field, linkGenerator, baseHeadingLevel + 1),
+    heading: field.name,
+    type: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Type",
+      value: linkGenerator(field.typeReference.rawDeclaration)
+    },
+    inherited: field.inherited,
+    accessModifier: field.access_modifier,
+    signature: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Signature",
+      value: buildSignature()
+    }
+  };
+}
+
+var __defProp$f = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+function typeToRenderable$1(parsedFile, linkGenerator, config) {
+  function getRenderable() {
+    const { type } = parsedFile;
+    switch (type.type_name) {
+      case "enum":
+        return enumTypeToEnumSource(type, linkGenerator);
+      case "interface":
+        return interfaceTypeToInterfaceSource(type, linkGenerator);
+      case "class":
+        return classTypeToClassSource(type, linkGenerator);
+    }
+  }
+  return __spreadProps$f(__spreadValues$f({}, getRenderable()), {
+    filePath: parsedFile.source.filePath,
+    namespace: config.namespace
+  });
+}
+function baseTypeAdapter(type, linkGenerator, baseHeadingLevel) {
+  function getHeading(type2) {
+    const suffixMap = {
+      class: "Class",
+      interface: "Interface",
+      enum: "Enum"
+    };
+    return `${type2.name} ${suffixMap[type2.type_name]}`;
+  }
+  return {
+    headingLevel: baseHeadingLevel,
+    heading: getHeading(type),
+    doc: adaptDocumentable(type, linkGenerator, baseHeadingLevel + 1),
+    name: type.name,
+    meta: {
+      accessModifier: type.access_modifier
+    }
+  };
+}
+function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
+  return __spreadProps$f(__spreadValues$f({
+    type: "enum"
+  }, baseTypeAdapter(enumType, linkGenerator, baseHeadingLevel)), {
+    values: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Values",
+      value: enumType.values.map((value) => {
+        var _a;
+        return __spreadProps$f(__spreadValues$f({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
+          value: value.name
+        });
+      })
+    }
+  });
+}
+function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadingLevel = 1) {
+  return __spreadProps$f(__spreadValues$f({
+    type: "interface"
+  }, baseTypeAdapter(interfaceType, linkGenerator, baseHeadingLevel)), {
+    extends: interfaceType.extended_interfaces.map(linkGenerator),
+    methods: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Methods",
+      value: interfaceType.methods.map((method) => adaptMethod(method, linkGenerator, baseHeadingLevel + 2))
+    }
+  });
+}
+function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1) {
+  return __spreadProps$f(__spreadValues$f({
+    type: "class"
+  }, baseTypeAdapter(classType, linkGenerator, baseHeadingLevel)), {
+    classModifier: classType.classModifier,
+    sharingModifier: classType.sharingModifier,
+    implements: classType.implemented_interfaces.map(linkGenerator),
+    extends: classType.inheritanceChain.map(linkGenerator),
+    methods: adaptMembers("Methods", classType.methods, adaptMethod, linkGenerator, baseHeadingLevel + 1),
+    constructors: adaptMembers(
+      "Constructors",
+      classType.constructors,
+      (constructor, linkGenerator2, baseHeadingLevel2) => adaptConstructor(classType.name, constructor, linkGenerator2, baseHeadingLevel2),
+      linkGenerator,
+      baseHeadingLevel + 1
+    ),
+    fields: adaptMembers(
+      "Fields",
+      classType.fields,
+      adaptFieldOrProperty,
+      linkGenerator,
+      baseHeadingLevel + 1
+    ),
+    properties: adaptMembers(
+      "Properties",
+      classType.properties,
+      adaptFieldOrProperty,
+      linkGenerator,
+      baseHeadingLevel + 1
+    ),
+    innerClasses: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Classes",
+      value: classType.classes.map(
+        (innerClass) => classTypeToClassSource(__spreadProps$f(__spreadValues$f({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
+      )
+    },
+    innerEnums: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Enums",
+      value: classType.enums.map((innerEnum) => enumTypeToEnumSource(innerEnum, linkGenerator, baseHeadingLevel + 2))
+    },
+    innerInterfaces: {
+      headingLevel: baseHeadingLevel + 1,
+      heading: "Interfaces",
+      value: classType.interfaces.map(
+        (innerInterface) => interfaceTypeToInterfaceSource(innerInterface, linkGenerator, baseHeadingLevel + 2)
+      )
+    }
+  });
+}
+function adaptMembers(heading, members, adapter, linkFromTypeNameGenerator, headingLevel) {
+  return {
+    headingLevel,
+    heading,
+    isGrouped: hasGroup(members),
+    value: hasGroup(members) ? toGroupedMembers(members, adapter, linkFromTypeNameGenerator, headingLevel + 1) : toFlat(members, adapter, linkFromTypeNameGenerator, headingLevel + 1)
+  };
+}
+function hasGroup(members) {
+  return members.some((member) => member.group);
+}
+function toFlat(members, adapter, linkGenerator, baseHeadingLevel) {
+  return members.map((member) => adapter(member, linkGenerator, baseHeadingLevel));
+}
+function toGroupedMembers(members, adapter, linkGenerator, baseHeadingLevel) {
+  const groupedMembers = groupByGroupName(members);
+  return Object.entries(groupedMembers).map(
+    ([groupName, members2]) => singleGroup(baseHeadingLevel, groupName, adapter, members2, linkGenerator)
+  );
+}
+function groupByGroupName(members) {
+  return members.reduce(
+    (acc, member) => {
+      var _a, _b;
+      const groupName = (_a = member.group) != null ? _a : "Other";
+      acc[groupName] = (_b = acc[groupName]) != null ? _b : [];
+      acc[groupName].push(member);
+      return acc;
+    },
+    {}
+  );
+}
+function singleGroup(headingLevel, groupName, adapter, members, linkGenerator) {
+  return {
+    headingLevel,
+    heading: groupName,
+    groupDescription: members[0].groupDescription,
+    // All fields in the group have the same description
+    value: toFlat(members, adapter, linkGenerator, headingLevel + 1)
+  };
+}
+
+const generateLink = (strategy) => {
+  switch (strategy) {
+    case "relative":
+      return generateRelativeLink;
+    case "no-link":
+      return generateNoLink;
+    case "none":
+      return returnReferenceAsIs;
+  }
+};
+const generateRelativeLink = (references, from, referenceName) => {
+  function getRelativePath(fromPath, toPath) {
+    return path.relative(path.parse(path.join("/", fromPath)).dir, path.join("/", toPath));
+  }
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+  if (referenceTo && from === "__base__") {
+    return {
+      __type: "link",
+      title: referenceTo.displayName,
+      url: getRelativePath("", referenceTo.referencePath)
+    };
+  }
+  const referenceFrom = references[from];
+  if (!referenceFrom) {
+    return referenceTo.displayName;
+  }
+  return {
+    __type: "link",
+    title: referenceTo.displayName,
+    url: getRelativePath(referenceFrom.referencePath, referenceTo.referencePath)
+  };
+};
+const generateNoLink = (references, _from, referenceName) => {
+  const referenceTo = references[referenceName];
+  return referenceTo ? referenceTo.displayName : referenceName;
+};
+const returnReferenceAsIs = (references, _from, referenceName) => {
+  const referenceTo = references[referenceName];
+  if (!referenceTo) {
+    return referenceName;
+  }
+  return {
+    __type: "link",
+    title: referenceTo.displayName,
+    url: referenceTo.referencePath
+  };
+};
+
+function parsedFilesToRenderableBundle(config, parsedFiles, references) {
+  const referenceFinder = apply(generateLink(config.linkingStrategy), references);
+  function toReferenceGuide(parsedFiles2) {
+    return parsedFiles2.reduce(
+      addToReferenceGuide(apply(referenceFinder, "__base__"), config, references),
+      {}
+    );
+  }
+  function toRenderables(parsedFiles2) {
+    return parsedFiles2.reduce((acc, parsedFile) => {
+      const renderable = typeToRenderable$1(parsedFile, apply(referenceFinder, parsedFile.source.name), config);
+      acc.push(renderable);
+      return acc;
+    }, []);
+  }
+  return {
+    referencesByGroup: toReferenceGuide(parsedFiles),
+    renderables: toRenderables(parsedFiles)
+  };
+}
+function addToReferenceGuide(findLinkFromHome, config, references) {
+  return (acc, parsedFile) => {
+    var _a, _b;
+    const group = getTypeGroup$1(parsedFile.type, config);
+    if (!acc[group]) {
+      acc[group] = [];
+    }
+    acc[group].push({
+      reference: references[parsedFile.type.name],
+      title: findLinkFromHome(parsedFile.type.name),
+      description: (_b = adaptDescribable((_a = parsedFile.type.docComment) == null ? void 0 : _a.descriptionLines, findLinkFromHome).description) != null ? _b : null
+    });
+    return acc;
+  };
+}
+function getTypeGroup$1(type, config) {
+  var _a, _b;
+  const groupAnnotation = (_a = type.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === "group");
+  return (_b = groupAnnotation == null ? void 0 : groupAnnotation.body) != null ? _b : config.defaultGroupName;
+}
+
+class ReflectionError {
+  constructor(file, message) {
+    this.file = file;
+    this.message = message;
+  }
+}
+class ReflectionErrors {
+  constructor(errors) {
+    this.errors = errors;
+    this._tag = "ReflectionErrors";
+  }
+}
+class HookError {
+  constructor(error) {
+    this.error = error;
+    this._tag = "HookError";
+  }
+}
+
+function parseApexMetadata(input) {
+  return _function.pipe(input, parse, E__namespace.map(toMap));
+}
+function parse(input) {
+  return E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(input), E__namespace.toError);
+}
+function toMap(metadata) {
+  const map = /* @__PURE__ */ new Map();
+  map.set("apiVersion", String(metadata.ApexClass.apiVersion));
+  if (metadata.ApexClass.status) {
+    map.set("status", String(metadata.ApexClass.status));
+  }
+  return map;
+}
+
+var __defProp$e = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
+var __hasOwnProp$e = Object.prototype.hasOwnProperty;
+var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$e.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b)) {
+      if (__propIsEnum$e.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+var __async$5 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function reflectAsync(rawSource) {
+  return __async$5(this, null, function* () {
+    return new Promise((resolve, reject) => {
+      const result = apexReflection.reflect(rawSource);
+      if (result.typeMirror) {
+        return resolve(result.typeMirror);
+      } else if (result.error) {
+        return reject(result.error);
+      } else {
+        return reject(new Error("Unknown error"));
+      }
+    });
+  });
+}
+function reflectBundles(apexBundles) {
+  const semiGroupReflectionError = {
+    concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
+  };
+  const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
+  return _function.pipe(apexBundles, A__namespace.traverse(Ap)(reflectBundle));
+}
+function reflectBundle(apexBundle) {
+  const convertToParsedFile = apply(toParsedFile, apexBundle.filePath);
+  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
+  return _function.pipe(apexBundle, reflectAsTask, TE__namespace.map(convertToParsedFile), TE__namespace.flatMap(withMetadata));
+}
+function reflectAsTask(apexBundle) {
+  return TE__namespace.tryCatch(
+    () => reflectAsync(apexBundle.content),
+    (error) => new ReflectionErrors([new ReflectionError(apexBundle.filePath, error.message)])
+  );
+}
+function toParsedFile(filePath, typeMirror) {
+  return {
+    source: {
+      filePath,
+      name: typeMirror.name,
+      type: typeMirror.type_name
+    },
+    type: typeMirror
+  };
+}
+function addMetadata(rawMetadataContent, parsedFile) {
+  return TE__namespace.fromEither(
+    _function.pipe(
+      parsedFile.type,
+      (type) => addFileMetadataToTypeAnnotation(type, rawMetadataContent),
+      E__namespace.map((type) => __spreadProps$e(__spreadValues$e({}, parsedFile), { type })),
+      E__namespace.mapLeft((error) => errorToReflectionErrors(error, parsedFile.source.filePath))
+    )
+  );
+}
+function errorToReflectionErrors(error, filePath) {
+  return new ReflectionErrors([new ReflectionError(filePath, error.message)]);
+}
+function addFileMetadataToTypeAnnotation(type, metadata) {
+  const concatAnnotationToType = apply(concatAnnotations, type);
+  return _function.pipe(
+    O__namespace.fromNullable(metadata),
+    O__namespace.map(concatAnnotationToType),
+    O__namespace.getOrElse(() => E__namespace.right(type))
+  );
+}
+function concatAnnotations(type, metadataInput) {
+  return _function.pipe(
+    metadataInput,
+    parseApexMetadata,
+    E__namespace.map((metadataMap) => __spreadProps$e(__spreadValues$e({}, type), {
+      annotations: [...type.annotations, ...mapToAnnotations(metadataMap)]
+    }))
+  );
+}
+function mapToAnnotations(metadata) {
+  return Array.from(metadata.entries()).map(([key, value]) => {
+    const declaration = `${key}: ${value}`;
+    return {
+      name: declaration,
+      type: declaration,
+      rawDeclaration: declaration
+    };
+  });
+}
+
+function createInheritanceChain(repository, classMirror) {
+  return _function.pipe(
+    O__namespace.fromNullable(classMirror.extended_class),
+    O__namespace.match(
+      () => [],
+      (extendedClassName) => inheritanceChainFromParentClassName(repository, extendedClassName)
+    )
+  );
+}
+function inheritanceChainFromParentClassName(repository, className) {
+  return _function.pipe(
+    O__namespace.fromNullable(repository.find((type) => type.name.toLowerCase() === className.toLowerCase())),
+    O__namespace.match(
+      () => [className],
+      (extendedClass) => [className, ...createInheritanceChain(repository, extendedClass)]
+    )
+  );
+}
+
+const parsedFilesToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => parsedFile.type);
+
+var __defProp$d = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
+var __hasOwnProp$d = Object.prototype.hasOwnProperty;
+var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$d.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b)) {
+      if (__propIsEnum$d.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+const addInheritanceChainToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => __spreadProps$d(__spreadValues$d({}, parsedFile), {
+  type: addInheritanceChain(parsedFile.type, parsedFilesToTypes(parsedFiles))
+}));
+function addInheritanceChain(current, repository) {
+  if (current.type_name === "enum" || current.type_name === "interface") {
+    return current;
+  } else {
+    const inheritanceChain = createInheritanceChain(repository, current);
+    return __spreadProps$d(__spreadValues$d({}, current), {
+      inheritanceChain
+    });
+  }
+}
+
+var __defProp$c = Object.defineProperty;
+var __defProps$c = Object.defineProperties;
+var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
+var __hasOwnProp$c = Object.prototype.hasOwnProperty;
+var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$c = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$c.call(b, prop))
+      __defNormalProp$c(a, prop, b[prop]);
+  if (__getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(b)) {
+      if (__propIsEnum$c.call(b, prop))
+        __defNormalProp$c(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
+const addInheritedMembersToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => addInheritedMembers(parsedFilesToTypes(parsedFiles), parsedFile));
+function addInheritedMembers(repository, parsedFile) {
+  function addInheritedMembersToType(repository2, current) {
+    if (current.type_name === "enum") {
+      return current;
+    } else if (current.type_name === "interface") {
+      return addInheritedInterfaceMethods(current, repository2);
+    } else {
+      return addInheritedClassMembers(current, repository2);
+    }
+  }
+  return __spreadProps$c(__spreadValues$c({}, parsedFile), {
+    type: addInheritedMembersToType(repository, parsedFile.type)
+  });
+}
+function addInheritedInterfaceMethods(interfaceMirror, repository) {
+  function methodAlreadyExists(memberName, members) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+  function parentExtractor(interfaceMirror2) {
+    return interfaceMirror2.extended_interfaces;
+  }
+  const parents = getParents(parentExtractor, interfaceMirror, repository);
+  return __spreadProps$c(__spreadValues$c({}, interfaceMirror), {
+    methods: parents.reduce(
+      (acc, currentValue) => [
+        ...acc,
+        ...currentValue.methods.filter((method) => !methodAlreadyExists(method.name, acc)).map((method) => __spreadProps$c(__spreadValues$c({}, method), {
+          inherited: true
+        }))
+      ],
+      interfaceMirror.methods
+    )
+  });
+}
+function addInheritedClassMembers(classMirror, repository) {
+  function memberAlreadyExists(memberName, members) {
+    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
+  }
+  function parentExtractor(classMirror2) {
+    return classMirror2.extended_class ? [classMirror2.extended_class] : [];
+  }
+  function filterMember(members, existing) {
+    return members.filter((member) => member.access_modifier.toLowerCase() !== "private").filter((member) => !memberAlreadyExists(member.name, existing)).map((member) => __spreadProps$c(__spreadValues$c({}, member), {
+      inherited: true
+    }));
+  }
+  const parents = getParents(parentExtractor, classMirror, repository);
+  return __spreadProps$c(__spreadValues$c({}, classMirror), {
+    fields: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.fields, acc)],
+      classMirror.fields
+    ),
+    properties: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.properties, acc)],
+      classMirror.properties
+    ),
+    methods: parents.reduce(
+      (acc, currentValue) => [...acc, ...filterMember(currentValue.methods, acc)],
+      classMirror.methods
+    )
+  });
+}
+function getParents(extendedNamesExtractor, current, repository) {
+  return _function.pipe(
+    extendedNamesExtractor(current),
+    (interfaces) => interfaces.map((interfaceName) => repository.find((type) => type.name === interfaceName)),
+    (interfaces = []) => interfaces.filter((type) => type !== void 0),
+    (interfaces) => interfaces.reduce(
+      (acc, current2) => [...acc, ...getParents(extendedNamesExtractor, current2, repository)],
+      interfaces
+    )
+  );
+}
+
+const typeDocPartial = `
+{{#> documentablePartialTemplate}}
+
+{{#if doc.group}}
+**Group** {{doc.group}}
+{{/if}}
+
+{{#if doc.author}}
+**Author** {{doc.author}}
+{{/if}}
+
+{{#if doc.date}}
+**Date** {{doc.date}}
+{{/if}}
+
+{{#each doc.sees}}
+**See** {{link this}}
+
+{{/each}}
+
+{{#if namespace}}
+## Namespace
+{{namespace}}
+{{/if}}
+
+{{/documentablePartialTemplate}}
+`.trim();
+
+const documentablePartialTemplate = `
+{{#each doc.annotations}}
+\`{{this}}\`
+{{/each}}
+
+{{{renderContent doc.description}}}
+
+{{#each doc.customTags}}
+**{{splitAndCapitalize name}}** 
+
+{{{renderContent description}}}
+
+{{/each}}
+
+{{> @partial-block}}
+
+{{#if doc.mermaid.value}}
+{{ heading doc.mermaid.headingLevel doc.mermaid.heading }}
+{{code doc.mermaid.value}}
+{{/if}}
+
+{{#if doc.example.value}}
+{{ heading doc.example.headingLevel doc.example.heading }}
+{{{renderContent doc.example.value}}}
+{{/if}}
+`.trim();
+
+const methodsPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{{ heading headingLevel (inlineCode heading) }}}
+
+{{#if inherited}}
+*Inherited*
+{{/if}}
+
+{{#> documentablePartialTemplate}}
+
+{{ heading signature.headingLevel signature.heading }}
+{{ code signature.value }}
+
+{{#if parameters.value}}
+{{ heading parameters.headingLevel parameters.heading }}
+| Name | Type | Description |
+|------|------|-------------|
+{{#each parameters.value}}
+| {{name}} | {{link type}} | {{{renderContent description}}} |
+{{/each}}
+{{/if}}
+
+{{ heading returnType.headingLevel returnType.heading }}
+**{{link returnType.value.type}}**
+
+{{#if returnType.value.description}}
+{{returnType.value.description}}
+{{/if}}
+
+{{#if throws.value}}
+{{ heading throws.headingLevel throws.heading }}
+{{#each throws.value}}
+{{link this.type}}: {{this.description}}
+
+{{/each}}
+{{/if}}
+{{/documentablePartialTemplate}}
+
+{{#unless @last}}---{{/unless}}
+
+{{/each}}
+`.trim();
+
+const groupedMembersPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{> (lookup .. "subTemplate") this}}
+{{/each}}
+`.trim();
+
+const constructorsPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{{ heading headingLevel (inlineCode heading) }}}
+
+{{#> documentablePartialTemplate}}
+
+{{ heading signature.headingLevel signature.heading }}
+{{ code signature.value }}
+
+{{#if parameters.value}}
+{{ heading parameters.headingLevel parameters.heading }}
+| Name | Type | Description |
+|------|------|-------------|
+{{#each parameters.value}}
+| {{name}} | {{link type}} | {{description}} |
+{{/each}}
+{{/if}}
+
+{{#if throws.value}}
+{{ heading throws.headingLevel throws.heading }}
+{{#each throws.value}}
+{{link this.type}}: {{this.description}}
+
+{{/each}}
+{{/if}}
+{{/documentablePartialTemplate}}
+
+{{#unless @last}}---{{/unless}}
+
+{{/each}}
+`.trim();
+
+const fieldsPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{{ heading headingLevel (inlineCode heading) }}}
+
+{{#if inherited}}
+*Inherited*
+{{/if}}
+
+{{#> documentablePartialTemplate }}
+
+{{ heading signature.headingLevel signature.heading }}
+{{ code signature.value }}
+
+{{ heading type.headingLevel type.heading }}
+{{link type.value}}
+
+{{/documentablePartialTemplate}}
+
+{{#unless @last}}---{{/unless}}
+
+{{/each}}
+`.trim();
+
+const classMarkdownTemplate = `
+{{ heading headingLevel heading }}
+{{#if classModifier}}
+\`{{classModifier}}\`
+{{/if}}
+
+{{> typeDocumentation}}
+
+{{#if extends.length}}
+**Inheritance**
+
+{{#each extends}}{{link this}}{{#unless @last}} < {{/unless}}{{/each}}
+{{/if}}
+
+{{#if implements}}
+**Implements**
+
+{{#each implements}}
+{{link this}}{{#unless @last}}, {{/unless}}
+{{/each}}
+{{/if}}
+
+{{#if fields.value}}
+{{#if fields.isGrouped}}
+{{> groupedMembersPartialTemplate fields subTemplate="fieldsPartialTemplate"}}
+{{else}}
+{{> fieldsPartialTemplate fields}}
+{{/if}}
+{{/if}}
+
+{{#if properties.value}}
+{{#if properties.isGrouped}}
+{{> groupedMembersPartialTemplate properties subTemplate="fieldsPartialTemplate"}}
+{{else}}
+{{> fieldsPartialTemplate properties}}
+{{/if}}
+{{/if}}
+
+{{#if constructors.value}}
+{{#if constructors.isGrouped}}
+{{> groupedMembersPartialTemplate constructors subTemplate="constructorsPartialTemplate"}}
+{{else}}
+{{> constructorsPartialTemplate constructors}}
+{{/if}}
+{{/if}}
+
+{{#if methods.value}}
+{{#if methods.isGrouped}}
+{{> groupedMembersPartialTemplate methods subTemplate="methodsPartialTemplate"}}
+{{else}}
+{{> methodsPartialTemplate methods}}
+{{/if}}
+{{/if}}
+
+{{#if innerClasses.value}}
+{{ heading innerClasses.headingLevel innerClasses.heading }}
+{{#each innerClasses.value}}
+{{> classTemplate this}}
+{{/each}}
+{{/if}}
+
+{{#if innerEnums.value}}
+{{ heading innerEnums.headingLevel innerEnums.heading }}
+{{#each innerEnums.value}}
+{{> enumTemplate this}}
+{{/each}}
+{{/if}}
+
+{{#if innerInterfaces.value}}
+{{ heading innerInterfaces.headingLevel innerInterfaces.heading }}
+{{#each innerInterfaces.value}}
+{{> interfaceTemplate this}}
+{{/each}}
+{{/if}}
+`.trim();
+
+const enumMarkdownTemplate = `
+{{ heading headingLevel heading }}
+
+{{> typeDocumentation }}
+
+{{ heading values.headingLevel values.heading }}
+| Value | Description |
+|-------|-------------|
+{{#each values.value}}
+| {{value}} | {{description}} |
+{{/each}}
+`.trim();
+
+const interfaceMarkdownTemplate = `
+{{ heading headingLevel heading }}
+
+{{> typeDocumentation }}
+
+{{#if extends}}
+**Extends**
+{{#each extends}}
+{{link this}}{{#unless @last}}, {{/unless}}
+{{/each}}
+{{/if}}
+
+{{#if methods}}
+{{> methodsPartialTemplate methods}}
+{{/if}}
+`.trim();
+
+class Template {
+  constructor() {
+    Handlebars.registerPartial("typeDocumentation", typeDocPartial);
+    Handlebars.registerPartial("documentablePartialTemplate", documentablePartialTemplate);
+    Handlebars.registerPartial("methodsPartialTemplate", methodsPartialTemplate);
+    Handlebars.registerPartial("constructorsPartialTemplate", constructorsPartialTemplate);
+    Handlebars.registerPartial("groupedMembersPartialTemplate", groupedMembersPartialTemplate);
+    Handlebars.registerPartial("fieldsPartialTemplate", fieldsPartialTemplate);
+    Handlebars.registerPartial("classTemplate", classMarkdownTemplate);
+    Handlebars.registerPartial("enumTemplate", enumMarkdownTemplate);
+    Handlebars.registerPartial("interfaceTemplate", interfaceMarkdownTemplate);
+    Handlebars.registerHelper("link", link);
+    Handlebars.registerHelper("code", convertCodeBlock);
+    Handlebars.registerHelper("renderContent", resolveRenderableContent);
+    Handlebars.registerHelper("heading", heading);
+    Handlebars.registerHelper("inlineCode", inlineCode);
+    Handlebars.registerHelper("splitAndCapitalize", splitAndCapitalize);
+  }
+  static getInstance() {
+    if (!Template.instance) {
+      Template.instance = new Template();
+    }
+    return Template.instance;
+  }
+  compile(request) {
+    const compiled = Handlebars.compile(request.template);
+    return compiled(request.source).trim().replace(/\n{3,}/g, "\n\n");
+  }
+}
+const splitAndCapitalize = (text) => {
+  const words = text.split(/[-_]+/);
+  const capitalizedWords = [];
+  for (const word of words) {
+    capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
+  }
+  return capitalizedWords.join(" ");
+};
+const heading = (level, text) => {
+  return `${"#".repeat(level)} ${text}`;
+};
+const inlineCode = (text) => {
+  return new Handlebars.SafeString(`\`${text}\``);
+};
+const convertCodeBlock = (codeBlock) => {
+  return new Handlebars.SafeString(
+    `
+\`\`\`${codeBlock.language}
+${codeBlock.content.join("\n")}
+\`\`\`
+  `.trim()
+  );
+};
+const resolveRenderableContent = (description) => {
+  if (!description) {
+    return "";
+  }
+  function reduceDescription(acc, curr) {
+    if (isEmptyLine(curr)) {
+      return acc + "\n";
+    }
+    if (isCodeBlock(curr)) {
+      return acc + convertCodeBlock(curr) + "\n";
+    }
+    if (isInlineCode(curr)) {
+      return acc + inlineCode(curr.content).toString() + " ";
+    } else {
+      return acc + Handlebars.escapeExpression(link(curr)).trim() + " ";
+    }
+  }
+  return description.reduce(reduceDescription, "").trim();
+};
+const link = (source) => {
+  if (typeof source === "string") {
+    return source;
+  } else {
+    return `[${source.title}](${source.url})`;
+  }
+};
+
+var __defProp$b = Object.defineProperty;
+var __defProps$b = Object.defineProperties;
+var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+const commonDefaults = {
+  targetDir: "./docs/"
+};
+const markdownDefaults = __spreadProps$b(__spreadValues$b({}, commonDefaults), {
+  scope: ["global"],
+  defaultGroupName: "Miscellaneous",
+  includeMetadata: false,
+  sortAlphabetically: false,
+  linkingStrategy: "relative",
+  referenceGuideTitle: "Apex Reference Guide",
+  excludeTags: []
+});
+const openApiDefaults = __spreadProps$b(__spreadValues$b({}, commonDefaults), {
+  fileName: "openapi",
+  title: "Apex REST API",
+  apiVersion: "1.0.0"
+});
+const changeLogDefaults = __spreadProps$b(__spreadValues$b({}, commonDefaults), {
+  fileName: "changelog",
+  scope: ["global"]
+});
+
+const convertToDocumentationBundle = (referenceGuideTitle, referenceGuideTemplate, { referencesByGroup, renderables }) => ({
+  referenceGuide: {
+    frontmatter: null,
+    content: referencesToReferenceGuideContent(referenceGuideTitle, referencesByGroup, referenceGuideTemplate),
+    outputDocPath: "index.md"
+  },
+  docs: renderables.map(
+    (renderable) => renderableToPageData(Object.values(referencesByGroup).flat(), renderable)
+  )
+});
+function referencesToReferenceGuideContent(referenceGuideTitle, references, template) {
+  function alphabetizeReferences(references2) {
+    return Object.keys(references2).sort((a, b) => a.localeCompare(b)).reduce((acc, key) => {
+      acc[key] = references2[key].sort((a, b) => a.title.toString().localeCompare(b.title.toString()));
+      return acc;
+    }, {});
+  }
+  return _function.pipe(
+    references,
+    alphabetizeReferences,
+    (references2) => compile$1({
+      template,
+      source: { referenceGuideTitle, references: references2 }
+    })
+  );
+}
+function renderableToPageData(referenceGuideReference, renderable) {
+  function buildDocOutput(renderable2, docContents) {
+    var _a;
+    const reference = referenceGuideReference.find(
+      (ref) => ref.reference.source.name.toLowerCase() === renderable2.name.toLowerCase()
+    );
+    return {
+      source: {
+        filePath: renderable2.filePath,
+        name: renderable2.name,
+        type: renderable2.type
+      },
+      outputDocPath: reference.reference.outputDocPath,
+      frontmatter: null,
+      content: docContents,
+      group: (_a = renderable2.doc.group) != null ? _a : markdownDefaults.defaultGroupName
+    };
+  }
+  return _function.pipe(renderable, resolveApexTypeTemplate, compile$1, (docContents) => buildDocOutput(renderable, docContents));
+}
+function resolveApexTypeTemplate(renderable) {
+  function getTemplate(renderable2) {
+    switch (renderable2.type) {
+      case "enum":
+        return enumMarkdownTemplate;
+      case "interface":
+        return interfaceMarkdownTemplate;
+      case "class":
+        return classMarkdownTemplate;
+    }
+  }
+  return {
+    template: getTemplate(renderable),
+    source: renderable
+  };
+}
+function compile$1(request) {
+  return Template.getInstance().compile(request);
+}
+
+var __defProp$a = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
+var __hasOwnProp$a = Object.prototype.hasOwnProperty;
+var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$a.call(b, prop))
+      __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b)) {
+      if (__propIsEnum$a.call(b, prop))
+        __defNormalProp$a(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+class Manifest {
+  /**
+   * Constructs a new Manifest object.
+   * @param types List of types to be wrapped by this object.
+   * @param isForInnerTypes Whether this manifest represent an inner type or not.
+   */
+  constructor(types, isForInnerTypes = false) {
+    this.types = types;
+    this.isForInnerTypes = isForInnerTypes;
+  }
+  filteredByAccessModifierAndAnnotations(modifiers) {
+    const filteredTypes = Manifest.filterAccessibleModifier(this.types, modifiers);
+    const typesToReturn = [];
+    for (const filteredType of filteredTypes) {
+      typesToReturn.push(Manifest.filterSingleType(filteredType, modifiers, this.isForInnerTypes));
+    }
+    return typesToReturn;
+  }
+  static filterSingleType(currentType, modifiers, isForInnerTypes) {
+    if (currentType.type_name === "enum") {
+      return currentType;
+    }
+    if (currentType.type_name === "interface") {
+      const currentInterface = currentType;
+      return __spreadProps$a(__spreadValues$a({}, currentType), {
+        methods: this.filterAccessibleModifier(currentInterface.methods, modifiers)
+      });
+    }
+    const currentClass = currentType;
+    const filteredClass = __spreadProps$a(__spreadValues$a({}, currentType), {
+      methods: this.filterAccessibleModifier(currentClass.methods, modifiers),
+      properties: this.filterAccessibleModifier(currentClass.properties, modifiers),
+      fields: this.filterAccessibleModifier(currentClass.fields, modifiers),
+      constructors: this.filterAccessibleModifier(currentClass.constructors, modifiers)
+    });
+    if (!isForInnerTypes) {
+      return __spreadProps$a(__spreadValues$a({}, filteredClass), {
+        enums: this.filterAccessibleModifier(currentClass.enums, modifiers),
+        interfaces: this.filterAccessibleModifier(currentClass.interfaces, modifiers),
+        classes: new Manifest(currentClass.classes, true).filteredByAccessModifierAndAnnotations(
+          modifiers
+        )
+      });
+    }
+    return filteredClass;
+  }
+  static filterAccessibleModifier(accessAndDocAware, modifiers) {
+    return accessAndDocAware.filter((type) => this.shouldFilterType(type, modifiers));
+  }
+  static shouldFilterType(accessAndDocAware, modifiers) {
+    var _a;
+    const hasIgnoreDocAnnotation = (_a = accessAndDocAware.docComment) == null ? void 0 : _a.annotations.some(
+      (annotation) => annotation.name.toLowerCase() === "ignore"
+    );
+    if (hasIgnoreDocAnnotation) {
+      return false;
+    }
+    return modifiers.includes(accessAndDocAware.access_modifier) || accessAndDocAware.annotations.some((annotation) => modifiers.includes(annotation.type.toLowerCase()));
+  }
+}
+
+var __defProp$9 = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+function filterScope(scopes, parsedFiles) {
+  return parsedFiles.filter(({ type }) => Manifest.shouldFilterType(type, scopes)).map((parsedFile) => {
+    return __spreadProps$9(__spreadValues$9({}, parsedFile), {
+      type: Manifest.filterSingleType(parsedFile.type, scopes, false)
+    });
+  });
+}
+
+const hookableTemplate = `
+{{#if frontmatter}}
+{{{frontmatter}}}
+{{/if}}
+
+{{{content}}}
+`.trim();
+
+var __defProp$8 = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+function sortTypesAndMembers(shouldSort, parsedFiles) {
+  return parsedFiles.map((parsedFile) => __spreadProps$8(__spreadValues$8({}, parsedFile), {
+    type: sortTypeMember(parsedFile.type, shouldSort)
+  })).sort((a, b) => sortByNames(shouldSort, a.type, b.type));
+}
+function sortByNames(shouldSort, a, b) {
+  if (shouldSort) {
+    return a.name.localeCompare(b.name);
+  }
+  return 0;
+}
+function sortNamed(shouldSort, items) {
+  return items.sort((a, b) => sortByNames(shouldSort, a, b));
+}
+function sortTypeMember(type, shouldSort) {
+  switch (type.type_name) {
+    case "enum":
+      return sortEnumValues(shouldSort, type);
+    case "interface":
+      return sortInterfaceMethods(shouldSort, type);
+    case "class":
+      return sortClassMembers(shouldSort, type);
+  }
+}
+function sortEnumValues(shouldSort, enumType) {
+  return __spreadProps$8(__spreadValues$8({}, enumType), {
+    values: sortNamed(shouldSort, enumType.values)
+  });
+}
+function sortInterfaceMethods(shouldSort, interfaceType) {
+  return __spreadProps$8(__spreadValues$8({}, interfaceType), {
+    methods: sortNamed(shouldSort, interfaceType.methods)
+  });
+}
+function sortClassMembers(shouldSort, classType) {
+  return __spreadProps$8(__spreadValues$8({}, classType), {
+    fields: sortNamed(shouldSort, classType.fields),
+    classes: sortNamed(shouldSort, classType.classes),
+    enums: sortNamed(shouldSort, classType.enums),
+    interfaces: sortNamed(shouldSort, classType.interfaces),
+    methods: sortNamed(shouldSort, classType.methods),
+    properties: sortNamed(shouldSort, classType.properties)
+  });
+}
+
+function isSkip(value) {
+  return Object.prototype.hasOwnProperty.call(value, "_tag") && value._tag === "Skip";
+}
+
+function parsedFilesToReferenceGuide(config, parsedFiles) {
+  return parsedFiles.reduce((acc, parsedFile) => {
+    acc[parsedFile.type.name] = parsedFileToDocPageReference(config, parsedFile);
+    return acc;
+  }, {});
+}
+function parsedFileToDocPageReference(config, parsedFile) {
+  const path = `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`;
+  return {
+    source: parsedFile.source,
+    displayName: parsedFile.type.name,
+    outputDocPath: path,
+    referencePath: path
+  };
+}
+function getTypeGroup(type, config) {
+  var _a, _b;
+  const groupAnnotation = (_a = type.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === "group");
+  return (_b = groupAnnotation == null ? void 0 : groupAnnotation.body) != null ? _b : config.defaultGroupName;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+
+var __defProp$7 = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+const removeExcludedTags = (excludedTags, parsedFiles) => {
+  return parsedFiles.map((parsedFile) => {
+    return __spreadProps$7(__spreadValues$7({}, parsedFile), {
+      type: removeExcludedTagsFromType(excludedTags, parsedFile.type)
+    });
+  });
+};
+const removeExcludedTagsFromType = (excludedTags, type) => {
+  return __spreadProps$7(__spreadValues$7({}, handleType(excludedTags, type)), {
+    docComment: removeExcludedTagsFromDocComment(excludedTags, type.docComment)
+  });
+};
+const handleType = (excludedTags, type) => {
+  switch (type.type_name) {
+    case "class":
+      return handleClass(excludedTags, type);
+    case "interface":
+      return handleInterface(excludedTags, type);
+    case "enum":
+      return type;
+  }
+};
+const handleClass = (excludedTags, classMirror) => {
+  return __spreadProps$7(__spreadValues$7({}, classMirror), {
+    methods: classMirror.methods.map((method) => removeExcludedTagsFromDocumentable(excludedTags, method)),
+    properties: classMirror.properties.map((property) => removeExcludedTagsFromDocumentable(excludedTags, property)),
+    fields: classMirror.fields.map((field) => removeExcludedTagsFromDocumentable(excludedTags, field)),
+    constructors: classMirror.constructors.map(
+      (constructor) => removeExcludedTagsFromDocumentable(excludedTags, constructor)
+    ),
+    enums: classMirror.enums.map((enumType) => removeExcludedTagsFromType(excludedTags, enumType)),
+    interfaces: classMirror.interfaces.map((interfaceType) => removeExcludedTagsFromType(excludedTags, interfaceType)),
+    classes: classMirror.classes.map((innerClass) => removeExcludedTagsFromType(excludedTags, innerClass))
+  });
+};
+const handleInterface = (excludedTags, interfaceMirror) => {
+  return __spreadProps$7(__spreadValues$7({}, interfaceMirror), {
+    methods: interfaceMirror.methods.map((method) => removeExcludedTagsFromDocumentable(excludedTags, method))
+  });
+};
+const removeExcludedTagsFromDocumentable = (excludedTags, documentable) => {
+  return __spreadProps$7(__spreadValues$7({}, documentable), {
+    docComment: removeExcludedTagsFromDocComment(excludedTags, documentable.docComment)
+  });
+};
+const removeExcludedTagsFromDocComment = (excludedTags, docComment) => {
+  const removerFn = apply(remove, excludedTags);
+  return _function.pipe(
+    O__namespace.fromNullable(docComment),
+    O__namespace.map((docComment2) => removeExcludedTagsFromAnnotations(excludedTags, docComment2)),
+    O__namespace.map((docComment2) => removeExampleTag(apply(removerFn, docComment2))),
+    O__namespace.map((docComment2) => removeParamTags(apply(removerFn, docComment2))),
+    O__namespace.map((docComment2) => removeReturnTag(apply(removerFn, docComment2))),
+    O__namespace.map((docComment2) => removeThrowsTag(apply(removerFn, docComment2))),
+    O__namespace.map((docComment2) => removeExceptionTag(apply(removerFn, docComment2))),
+    O__namespace.map((docComment2) => removeDescription(apply(removerFn, docComment2))),
+    O__namespace.fold(
+      () => void 0,
+      (updatedDocComment) => updatedDocComment
+    )
+  );
+};
+const removeExcludedTagsFromAnnotations = (excludedTags, docComment) => {
+  return _function.pipe(
+    O__namespace.some(docComment.annotations),
+    O__namespace.map((annotations) => annotations.filter((annotation) => !includesIgnoreCase(excludedTags, annotation.name))),
+    O__namespace.fold(
+      () => docComment,
+      (filteredAnnotations) => __spreadProps$7(__spreadValues$7({}, docComment), {
+        annotations: filteredAnnotations
+      })
+    )
+  );
+};
+const removeExampleTag = (remover) => {
+  return remover("example", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      exampleAnnotation: null
+    });
+  });
+};
+const removeParamTags = (remover) => {
+  return remover("param", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      paramAnnotations: []
+    });
+  });
+};
+const removeReturnTag = (remover) => {
+  return remover("return", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      returnAnnotation: null
+    });
+  });
+};
+const removeThrowsTag = (remover) => {
+  return remover("throws", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      throwsAnnotations: []
+    });
+  });
+};
+const removeExceptionTag = (remover) => {
+  return remover("exception", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      throwsAnnotations: []
+    });
+  });
+};
+const removeDescription = (remover) => {
+  return remover("description", (docComment) => {
+    return __spreadProps$7(__spreadValues$7({}, docComment), {
+      description: "",
+      descriptionLines: []
+    });
+  });
+};
+const remove = (excludedTags, docComment, tagName, removeFn) => {
+  return boolean.match(
+    () => docComment,
+    () => removeFn(docComment)
+  )(includesIgnoreCase(excludedTags, tagName) && !!docComment);
+};
+const includesIgnoreCase = (excluded, value) => {
+  return excluded.some((element) => element.toLowerCase() === value.toLowerCase());
+};
+
+var __defProp$6 = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+var __async$4 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function generateDocs(apexBundles, config) {
+  const filterOutOfScope = apply(filterScope, config.scope);
+  const convertToReferences = apply(parsedFilesToReferenceGuide, config);
+  const convertToRenderableBundle = apply(parsedFilesToRenderableBundle, config);
+  const convertToDocumentationBundleForTemplate = apply(
+    convertToDocumentationBundle,
+    config.referenceGuideTitle,
+    config.referenceGuideTemplate
+  );
+  const sort = apply(sortTypesAndMembers, config.sortAlphabetically);
+  const removeExcluded = apply(removeExcludedTags, config.excludeTags);
+  return _function.pipe(
+    apexBundles,
+    reflectBundles,
+    TE__namespace.map(filterOutOfScope),
+    TE__namespace.map(addInheritedMembersToTypes),
+    TE__namespace.map(addInheritanceChainToTypes),
+    TE__namespace.map(sort),
+    TE__namespace.map(removeExcluded),
+    TE__namespace.bindTo("parsedFiles"),
+    TE__namespace.bind("references", ({ parsedFiles }) => TE__namespace.right(convertToReferences(parsedFiles))),
+    TE__namespace.flatMap(({ parsedFiles, references }) => transformReferenceHook(config)({ references, parsedFiles })),
+    TE__namespace.map(({ parsedFiles, references }) => convertToRenderableBundle(parsedFiles, references)),
+    TE__namespace.map(convertToDocumentationBundleForTemplate),
+    TE__namespace.flatMap(transformDocumentationBundleHook(config)),
+    TE__namespace.map(postHookCompile)
+  );
+}
+function transformReferenceHook(config) {
+  function _execute(references, parsedFiles, transformReference) {
+    return __async$4(this, null, function* () {
+      return {
+        references: yield execTransformReferenceHook(Object.values(references), transformReference),
+        parsedFiles
+      };
+    });
+  }
+  return ({ references, parsedFiles }) => TE__namespace.tryCatch(
+    () => _execute(references, parsedFiles, config.transformReference),
+    (error) => new HookError(error)
+  );
+}
+function transformDocumentationBundleHook(config) {
+  return (bundle) => TE__namespace.tryCatch(
+    () => documentationBundleHook(bundle, config),
+    (error) => new HookError(error)
+  );
+}
+function passThroughHook(value) {
+  return value;
+}
+const execTransformReferenceHook = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
+  const hooked = references.map((reference) => __async$4(void 0, null, function* () {
+    const hookedResult = yield hook(reference);
+    return __spreadValues$6(__spreadValues$6({}, reference), hookedResult);
+  }));
+  const awaited = yield Promise.all(hooked);
+  return awaited.reduce((acc, reference) => {
+    acc[reference.source.name] = reference;
+    return acc;
+  }, {});
+});
+const documentationBundleHook = (bundle, config) => __async$4(void 0, null, function* () {
+  return {
+    referenceGuide: yield transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
+    docs: yield transformDocs(bundle.docs, config.transformDocs, config.transformDocPage)
+  };
+});
+const transformReferenceGuide = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
+  const result = yield hook(referenceGuide);
+  if (isSkip(result)) {
+    return result;
+  }
+  return __spreadValues$6(__spreadValues$6({}, referenceGuide), yield hook(referenceGuide));
+});
+const transformDocs = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
+  const transformed = yield transformDocsHook(docs);
+  return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
+});
+const transformDocPage = (_0, ..._1) => __async$4(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
+  return __spreadValues$6(__spreadValues$6({}, doc), yield hook(doc));
+});
+function postHookCompile(bundle) {
+  return {
+    referenceGuide: isSkip(bundle.referenceGuide) ? bundle.referenceGuide : __spreadProps$6(__spreadValues$6({}, bundle.referenceGuide), {
+      content: Template.getInstance().compile({
+        source: {
+          frontmatter: toFrontmatterString(bundle.referenceGuide.frontmatter),
+          content: bundle.referenceGuide.content
+        },
+        template: hookableTemplate
+      })
+    }),
+    docs: bundle.docs.map((doc) => __spreadProps$6(__spreadValues$6({}, doc), {
+      content: Template.getInstance().compile({
+        source: {
+          frontmatter: toFrontmatterString(doc.frontmatter),
+          content: doc.content
+        },
+        template: hookableTemplate
+      })
+    }))
+  };
+}
+function toFrontmatterString(frontmatter) {
+  if (typeof frontmatter === "string") {
+    return frontmatter;
+  }
+  if (!frontmatter) {
+    return "";
+  }
+  const yamlString = yaml.dump(frontmatter);
+  return `---
+${yamlString}---
+`;
+}
+
+const referenceGuideTemplate = `
+# {{referenceGuideTitle}}
+
+{{#each references}}
+## {{@key}}
+
+{{#each this}}
+### {{link title}}
+
+{{{renderContent description}}}
+
+{{/each}}
+{{/each}}
+`.trim();
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+const mkdir = TE__namespace$1.taskify(fs__namespace.mkdir);
+const writeFile = TE__namespace$1.taskify(fs__namespace.writeFile);
+function writeFiles(files, outputDir, onWriteCallback) {
+  return _function.pipe(
+    files,
+    TE__namespace$1.traverseArray((file) => writeSingle(file, outputDir, onWriteCallback))
+  );
+}
+function writeSingle(file, outputDir, onWriteCallback) {
+  const ensureDirectoryExists = ({ outputDocPath }) => mkdir(path__namespace.dirname(outputDocPath), { recursive: true });
+  const writeContents = (file2) => writeFile(file2.outputDocPath, file2.content, "utf8");
+  return _function.pipe(
+    resolveTargetLocation(file, outputDir),
+    (file2) => TE__namespace$1.right(file2),
+    TE__namespace$1.tapIO(ensureDirectoryExists),
+    TE__namespace$1.flatMap(writeContents),
+    TE__namespace$1.map(() => onWriteCallback == null ? void 0 : onWriteCallback(file))
+  );
+}
+function resolveTargetLocation(file, outputDir) {
+  return __spreadProps$5(__spreadValues$5({}, file), {
+    outputDocPath: path__namespace.join(outputDir, file.outputDocPath)
+  });
+}
+
+class FileReadingError {
+  constructor(message, error) {
+    this.message = message;
+    this.error = error;
+    this._tag = "FileReadingError";
+  }
+}
+class FileWritingError {
+  constructor(message, error) {
+    this.message = message;
+    this.error = error;
+    this._tag = "FileWritingError";
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+function generate$1(bundles, config) {
+  return _function.pipe(
+    generateDocumentationBundle(bundles, config),
+    TE__namespace.flatMap((files) => writeFilesToSystem$1(files, config.targetDir))
+  );
+}
+function generateDocumentationBundle(bundles, config) {
+  return generateDocs(bundles, __spreadProps$4(__spreadValues$4({}, config), {
+    referenceGuideTemplate
+  }));
+}
+function writeFilesToSystem$1(files, outputDir) {
+  return _function.pipe(
+    [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
+    (files2) => writeFiles(files2, outputDir),
+    TE__namespace.mapLeft((error) => {
+      return new FileWritingError("An error occurred while writing files to the system.", error);
+    })
+  );
+}
+
+function createManifest(typeParser, reflect) {
+  return new Manifest(typeParser.parse(reflect));
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+class RawBodyParser {
+  constructor(logger, typeBundles) {
+    this.logger = logger;
+    this.typeBundles = typeBundles;
+  }
+  parse(reflect) {
+    const types = this.typeBundles.map((currentBundle) => {
+      this.logger.log(`Parsing file: ${currentBundle.filePath}`);
+      return reflect(currentBundle);
+    }).filter((reflectionResult) => {
+      return reflectionResult.typeMirror;
+    }).map((reflectionResult) => reflectionResult.typeMirror);
+    return this.addFieldsFromParent(types);
+  }
+  addFieldsFromParent(types) {
+    const typesWithFields = [];
+    for (const currentType of types) {
+      if (currentType.type_name !== "class" && currentType.type_name !== "interface") {
+        typesWithFields.push(currentType);
+        continue;
+      }
+      if (currentType.type_name === "class") {
+        let typeAsClass = currentType;
+        if (!typeAsClass.extended_class) {
+          typesWithFields.push(currentType);
+          continue;
+        }
+        typeAsClass = this.addMembersFromParent(typeAsClass, types);
+        typesWithFields.push(typeAsClass);
+        continue;
+      }
+      let typeAsInterface = currentType;
+      if (!typeAsInterface.extended_interfaces.length) {
+        typesWithFields.push(currentType);
+        continue;
+      }
+      typeAsInterface = this.addMethodsFromParent(typeAsInterface, types);
+      typesWithFields.push(typeAsInterface);
+    }
+    return typesWithFields;
+  }
+  addMembersFromParent(currentClass, allTypes) {
+    if (!currentClass.extended_class) {
+      return currentClass;
+    }
+    const parent = allTypes.find((currentType) => currentType.name === currentClass.extended_class);
+    if (!parent || parent.type_name !== "class") {
+      return currentClass;
+    }
+    let parentAsClass = parent;
+    if (parentAsClass.extended_class) {
+      parentAsClass = this.addMembersFromParent(parentAsClass, allTypes);
+    }
+    currentClass.fields = [...currentClass.fields, ...this.getInheritedFields(parentAsClass, currentClass)];
+    currentClass.properties = [...currentClass.properties, ...this.getInheritedProperties(parentAsClass, currentClass)];
+    currentClass.methods = [...currentClass.methods, ...this.getInheritedMethods(parentAsClass, currentClass)];
+    return currentClass;
+  }
+  addMethodsFromParent(currentInterface, allTypes) {
+    if (!currentInterface.extended_interfaces.length) {
+      return currentInterface;
+    }
+    const parents = [];
+    for (const currentInterfaceName of currentInterface.extended_interfaces) {
+      const parent = allTypes.find((currentType) => currentType.name === currentInterfaceName);
+      if (parent) {
+        parents.push(parent);
+      }
+    }
+    for (const parent of parents) {
+      let parentAsInterface = parent;
+      if (parentAsInterface.extended_interfaces.length) {
+        parentAsInterface = this.addMethodsFromParent(parentAsInterface, allTypes);
+      }
+      currentInterface.methods = [
+        ...currentInterface.methods,
+        ...this.getInheritedMethods(parentAsInterface, currentInterface)
+      ];
+    }
+    return currentInterface;
+  }
+  getInheritedFields(parentAsClass, currentClass) {
+    return parentAsClass.fields.filter((currentField) => currentField.access_modifier.toLowerCase() !== "private").filter((currentField) => !this.memberExists(currentClass.fields, currentField.name)).map((currentField) => __spreadProps$3(__spreadValues$3({}, currentField), {
+      inherited: true
+    }));
+  }
+  getInheritedProperties(parentAsClass, currentClass) {
+    return parentAsClass.properties.filter((currentProperty) => currentProperty.access_modifier.toLowerCase() !== "private").filter((currentProperty) => !this.memberExists(currentClass.properties, currentProperty.name)).map((currentProperty) => __spreadProps$3(__spreadValues$3({}, currentProperty), {
+      inherited: true
+    }));
+  }
+  getInheritedMethods(parentAsClass, currentClass) {
+    return parentAsClass.methods.filter((currentMethod) => currentMethod.access_modifier.toLowerCase() !== "private").filter((currentMethod) => !this.memberExists(currentClass.methods, currentMethod.name)).map((currentMethod) => __spreadProps$3(__spreadValues$3({}, currentMethod), {
+      inherited: true
+    }));
+  }
+  memberExists(members, fieldName) {
+    const fieldNames = members.map((currentMember) => currentMember.name);
+    return fieldNames.includes(fieldName);
+  }
+}
+
+class TypesRepository {
+  constructor() {
+    this.allTypes = [];
+  }
+  static getInstance() {
+    if (!TypesRepository.instance) {
+      TypesRepository.instance = new TypesRepository();
+    }
+    return TypesRepository.instance;
+  }
+  populateAll(types) {
+    this.allTypes = types;
+  }
+  getFromAllByName(typeName) {
+    if (typeName.includes(".")) {
+      const [parentTypeName, childTypeName] = typeName.split(".");
+      const parentReference = this.allTypes.find(
+        (currentType) => currentType.name.toLowerCase() === parentTypeName.toLowerCase()
+      );
+      if (!parentReference || parentReference.type_name !== "class") {
+        return void 0;
+      }
+      const parentReferenceAsClass = parentReference;
+      const childTypes = [
+        ...parentReferenceAsClass.classes,
+        ...parentReferenceAsClass.interfaces,
+        ...parentReferenceAsClass.enums
+      ];
+      const foundType2 = childTypes.find((currentType) => currentType.name.toLowerCase() === childTypeName);
+      if (!foundType2) {
+        return void 0;
+      }
+      return { type: foundType2, isChild: true, parentType: parentReference };
+    }
+    const foundType = this.allTypes.find(
+      (currentType) => currentType.name.toLowerCase() === typeName.toLowerCase()
+    );
+    if (!foundType) {
+      return void 0;
+    }
+    return { type: foundType, isChild: false };
+  }
+}
+
+class Transpiler {
+  static generate(types, processor) {
+    var _a;
+    const sortedTypes = types.sort((apexTypeA, apexTypeB) => {
+      if (apexTypeA.name < apexTypeB.name) return -1;
+      if (apexTypeA.name > apexTypeB.name) return 1;
+      return 0;
+    });
+    sortedTypes.forEach((currentType) => {
+      processor.onProcess(currentType);
+    });
+    (_a = processor.onAfterProcess) == null ? void 0 : _a.call(processor, sortedTypes);
+  }
+}
+
+class ErrorLogger {
+  static logErrors(logger, types) {
+    types.forEach((currentType) => {
+      this.logErrorsForSingleType(logger, currentType);
+    });
+  }
+  static logErrorsForSingleType(logger, currentType) {
+    this.logTypeErrors(logger, currentType);
+    if (currentType.type_name === "class") {
+      this.logErrorsForClass(logger, currentType);
+    } else if (currentType.type_name === "interface") {
+      this.logErrorsForInterface(logger, currentType);
+    }
+  }
+  static logTypeErrors(logger, currentType, parentType) {
+    var _a;
+    if ((_a = currentType.docComment) == null ? void 0 : _a.error) {
+      const typeName = parentType ? `${parentType.name}.${currentType.name}` : currentType.name;
+      logger.error(`${typeName} - Doc comment parsing error. Level: Type`);
+      logger.error(`Comment:
+ ${currentType.docComment.rawDeclaration}`);
+      logger.error(currentType.docComment.error);
+      logger.error("=================================");
+    }
+  }
+  static logErrorsForClass(logger, classMirror, parentType) {
+    const typeName = parentType ? `${parentType.name}.${classMirror.name}` : classMirror.name;
+    classMirror.constructors.forEach((currentConstructor) => {
+      var _a;
+      if ((_a = currentConstructor.docComment) == null ? void 0 : _a.error) {
+        logger.error(`${typeName} - Doc comment parsing error. Level: Constructor`);
+        logger.error(`Comment:
+ ${currentConstructor.docComment.rawDeclaration}`);
+        logger.error(currentConstructor.docComment.error);
+        logger.error("=================================");
+      }
+    });
+    classMirror.fields.forEach((currentField) => {
+      var _a;
+      if ((_a = currentField.docComment) == null ? void 0 : _a.error) {
+        logger.error(`${typeName} - Doc comment parsing error. Level: Field`);
+        logger.error(`Comment:
+ ${currentField.docComment.rawDeclaration}`);
+        logger.error(currentField.docComment.error);
+        logger.error("=================================");
+      }
+    });
+    classMirror.properties.forEach((currentProperty) => {
+      var _a;
+      if ((_a = currentProperty.docComment) == null ? void 0 : _a.error) {
+        logger.error(`${typeName} - Doc comment parsing error. Level: Property`);
+        logger.error(`Comment:
+ ${currentProperty.docComment.rawDeclaration}`);
+        logger.error(currentProperty.docComment.error);
+        logger.error("=================================");
+      }
+    });
+    classMirror.methods.forEach((currentMethod) => {
+      var _a;
+      if ((_a = currentMethod.docComment) == null ? void 0 : _a.error) {
+        logger.error(`${typeName} - Doc comment parsing error. Level: Method`);
+        logger.error(`Comment:
+ ${currentMethod.docComment.rawDeclaration}`);
+        logger.error(currentMethod.docComment.error);
+        logger.error("=================================");
+      }
+    });
+    classMirror.enums.forEach((currentEnum) => {
+      this.logErrorsForSingleType(logger, currentEnum);
+    });
+    classMirror.interfaces.forEach((currentInterface) => {
+      this.logErrorsForSingleType(logger, currentInterface);
+    });
+    classMirror.classes.forEach((currentClass) => {
+      this.logErrorsForSingleType(logger, currentClass);
+    });
+  }
+  static logErrorsForInterface(logger, interfaceMirror) {
+    interfaceMirror.methods.forEach((currentMethod) => {
+      var _a;
+      if ((_a = currentMethod.docComment) == null ? void 0 : _a.error) {
+        logger.error(`${interfaceMirror.name} - Doc comment parsing error. Level: Method`);
+        logger.error(`Comment: ${currentMethod.docComment.rawDeclaration}`);
+        logger.error(currentMethod.docComment.error);
+        logger.error("=================================");
+      }
+    });
+  }
+}
+
+class FileContainer {
+  constructor() {
+    this._files = [];
+  }
+  files() {
+    return this._files;
+  }
+  pushFile(file) {
+    this._files.push(file);
+  }
+}
+
+const OPEN_API_VERSION = "3.1.0";
+const SERVER_URL = "/services/apexrest/";
+class OpenApi {
+  constructor(title, version, namespace) {
+    this.namespace = namespace;
+    this.openapi = OPEN_API_VERSION;
+    this.info = {
+      title,
+      version
+    };
+    this.servers = [
+      {
+        url: this.getServerUrl()
+      }
+    ];
+    this.paths = {};
+    this.tags = [];
+  }
+  getServerUrl() {
+    if (!this.namespace) {
+      return SERVER_URL;
+    }
+    return `${SERVER_URL}${this.namespace}/`;
+  }
+}
+
+class OpenApiSettings {
+  constructor(config) {
+    this.config = config;
+  }
+  static build(config) {
+    OpenApiSettings.instance = new OpenApiSettings(config);
+  }
+  static getInstance() {
+    if (!OpenApiSettings.instance) {
+      throw new Error("Settings has not been initialized");
+    }
+    return OpenApiSettings.instance;
+  }
+  getOpenApiTitle() {
+    return this.config.openApiTitle;
+  }
+  getNamespace() {
+    return this.config.namespace;
+  }
+  openApiFileName() {
+    return this.config.openApiFileName;
+  }
+  getVersion() {
+    return this.config.version;
+  }
+}
+
+class ClassMirrorWrapper {
+  constructor(classMirror) {
+    this.classMirror = classMirror;
+    this.hasAnnotation = (method, annotationName) => method.annotations.some((annotation) => annotation.name.toLowerCase() === annotationName);
+  }
+  getMethodsByAnnotation(annotation) {
+    return this.classMirror.methods.filter((method) => this.hasAnnotation(method, annotation));
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+class ReferenceBuilder {
+  constructor() {
+    this.isReferenceString = (targetObject) => {
+      return typeof targetObject === "string" || targetObject instanceof String;
+    };
+  }
+  build(referencedTypeName) {
+    const originalTypeName = referencedTypeName;
+    const regexForSchemaOverrides = /\[(.*?)]/g;
+    const schemaOverrides = referencedTypeName.match(regexForSchemaOverrides);
+    let referenceOverrides = [];
+    if (schemaOverrides && schemaOverrides.length > 0) {
+      referenceOverrides = ReferenceOverrides.build(schemaOverrides[0]);
+      referencedTypeName = referencedTypeName.replace(regexForSchemaOverrides, "");
+    }
+    const [parsedReferencedType, isCollection] = this.handlePossibleCollectionReference(referencedTypeName);
+    const referencedTypeBundle = TypesRepository.getInstance().getFromAllByName(parsedReferencedType);
+    if (!referencedTypeBundle) {
+      throw new Error(`The referenced type ${referencedTypeName} was not found.`);
+    }
+    if (referencedTypeBundle.type.type_name !== "class") {
+      throw new Error(
+        `Expected the referenced type to be a class, but found a ${referencedTypeBundle.type.type_name}.`
+      );
+    }
+    const typeBundleWithIsCollection = __spreadProps$2(__spreadValues$2({}, referencedTypeBundle), {
+      originalTypeName,
+      isCollection,
+      referenceOverrides
+    });
+    return this.buildReferenceFromType(typeBundleWithIsCollection);
+  }
+  /**
+   * Returns a tuple where the first value is the name of the reference without any collection related values
+   * and the second is a boolean representing if we are dealing with a collection or not.
+   * @param referencedTypeName The received raw type name.
+   * @private
+   */
+  handlePossibleCollectionReference(referencedTypeName) {
+    referencedTypeName = referencedTypeName.toLowerCase();
+    if (referencedTypeName.startsWith("list<") && referencedTypeName.endsWith(">")) {
+      referencedTypeName = referencedTypeName.replace("list<", "");
+      referencedTypeName = referencedTypeName.replace(">", "");
+      return [referencedTypeName, true];
+    }
+    if (referencedTypeName.startsWith("set<") && referencedTypeName.endsWith(">")) {
+      referencedTypeName = referencedTypeName.replace("set<", "");
+      referencedTypeName = referencedTypeName.replace(">", "");
+      return [referencedTypeName, true];
+    }
+    return [referencedTypeName, false];
+  }
+  buildReferenceFromType(typeBundle) {
+    const propertiesAndFields = [
+      ...typeBundle.type.properties,
+      ...typeBundle.type.fields
+    ].filter((current) => !current.memberModifiers.includes("static")).filter((current) => !current.memberModifiers.includes("transient"));
+    const properties = {};
+    let referencedComponents = [];
+    propertiesAndFields.forEach((current) => {
+      var _a, _b;
+      const referenceOverride = typeBundle.referenceOverrides.find((currentOverride) => {
+        return currentOverride.propertyName.toLowerCase() === current.name.toLowerCase();
+      });
+      if (referenceOverride) {
+        const reference = this.build(referenceOverride.referenceName);
+        properties[current.name] = reference.entrypointReferenceObject;
+        reference.referenceComponents.forEach((current2) => referencedComponents.push(current2));
+      } else {
+        const manuallyDefinedHttpSchema = (_a = current.docComment) == null ? void 0 : _a.annotations.find(
+          (annotation) => annotation.name.toLowerCase() === "http-schema"
+        );
+        if (manuallyDefinedHttpSchema) {
+          this.handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents);
+        } else {
+          const pair = this.getReferenceType(current.typeReference);
+          properties[current.name] = pair.schema;
+          referencedComponents.push(...pair.referenceComponents);
+        }
+      }
+      properties[current.name].description = (_b = current.docComment) == null ? void 0 : _b.description;
+    });
+    const mainReferenceComponents = this.buildMainReferenceComponent(typeBundle, properties);
+    referencedComponents = [...mainReferenceComponents, ...referencedComponents];
+    return {
+      entrypointReferenceObject: {
+        $ref: `#/components/schemas/${this.getReferenceName(typeBundle)}`
+      },
+      referenceComponents: referencedComponents
+    };
+  }
+  handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents) {
+    const inYaml = manuallyDefinedHttpSchema == null ? void 0 : manuallyDefinedHttpSchema.bodyLines.reduce((prev, current2) => prev + "\n" + current2);
+    const asJson = yaml__namespace.load(inYaml);
+    const isReferenceString = this.isReferenceString(asJson);
+    if (isReferenceString) {
+      const reference = this.build(asJson);
+      properties[current.name] = reference.entrypointReferenceObject;
+      reference.referenceComponents.forEach((current2) => referencedComponents.push(current2));
+    } else {
+      properties[current.name] = asJson;
+    }
+  }
+  getReferenceName(typeBundle) {
+    var _a;
+    let referenceName = typeBundle.type.name;
+    if (typeBundle.isChild) {
+      referenceName = `${(_a = typeBundle.parentType) == null ? void 0 : _a.name}.${typeBundle.type.name}`;
+    }
+    if (typeBundle.isCollection) {
+      referenceName = `${referenceName}_array`;
+    }
+    if (typeBundle.referenceOverrides.length) {
+      referenceName = `${referenceName}_${typeBundle.originalTypeName}`;
+    }
+    return referenceName;
+  }
+  buildMainReferenceComponent(typeBundle, properties) {
+    const mainReferenceName = this.getReferenceName(__spreadProps$2(__spreadValues$2({}, typeBundle), { isCollection: false }));
+    const mainReference = {
+      referencedClass: mainReferenceName,
+      schema: {
+        type: "object",
+        properties
+      }
+    };
+    const referencedComponents = [mainReference];
+    if (!typeBundle.isCollection) {
+      return referencedComponents;
+    }
+    return [
+      {
+        referencedClass: this.getReferenceName(typeBundle),
+        schema: {
+          type: "array",
+          items: {
+            $ref: `#/components/schemas/${mainReferenceName}`
+          }
+        }
+      },
+      ...referencedComponents
+    ];
+  }
+  getReferenceType(typeInMirror) {
+    const typeName = typeInMirror.type.toLowerCase();
+    switch (typeName) {
+      case "boolean":
+        return { schema: { type: "boolean" }, referenceComponents: [] };
+      case "date":
+        return { schema: { type: "string", format: "date" }, referenceComponents: [] };
+      case "datetime":
+        return { schema: { type: "string", format: "date-time" }, referenceComponents: [] };
+      case "decimal":
+        return { schema: { type: "number" }, referenceComponents: [] };
+      case "double":
+        return { schema: { type: "number" }, referenceComponents: [] };
+      case "id":
+        return { schema: { type: "string" }, referenceComponents: [] };
+      case "integer":
+        return { schema: { type: "integer" }, referenceComponents: [] };
+      case "long":
+        return { schema: { type: "integer", format: "int64" }, referenceComponents: [] };
+      case "string":
+        return { schema: { type: "string" }, referenceComponents: [] };
+      case "time":
+        return { schema: { type: "string", format: "time" }, referenceComponents: [] };
+      case "list":
+        return this.buildCollectionPair(typeInMirror);
+      case "set":
+        return this.buildCollectionPair(typeInMirror);
+      case "map":
+        return { schema: { type: "object" }, referenceComponents: [] };
+      case "object":
+        return { schema: { type: "object" }, referenceComponents: [] };
+      default: {
+        const referencedType = TypesRepository.getInstance().getFromAllByName(typeName);
+        if (!referencedType) {
+          return { schema: { type: "object" }, referenceComponents: [] };
+        }
+        const reference = this.buildReferenceFromType(__spreadProps$2(__spreadValues$2({}, referencedType), {
+          isCollection: false,
+          referenceOverrides: [],
+          originalTypeName: typeName
+        }));
+        return {
+          schema: reference.entrypointReferenceObject,
+          referenceComponents: [...reference.referenceComponents]
+        };
+      }
+    }
+  }
+  buildCollectionPair(typeInMirror) {
+    const innerReference = this.getReferenceType(typeInMirror.ofType);
+    return {
+      schema: { type: "array", items: innerReference.schema },
+      referenceComponents: [...innerReference.referenceComponents]
+    };
+  }
+}
+class ReferenceOverrides {
+  static build(referenceAsString) {
+    const cleanedUpReference = referenceAsString.replace(/[[\]]/g, "");
+    const referenceStrings = cleanedUpReference.split(",").map((item) => item.replace(/\s/g, ""));
+    return referenceStrings.map((item) => {
+      const [propertyName, referenceName] = item.split(":");
+      return { propertyName, referenceName };
+    });
+  }
+}
+
+class Builder {
+  constructor() {
+    this.isReferenceString = (targetObject) => {
+      return typeof targetObject === "string" || targetObject instanceof String;
+    };
+  }
+  build(schemaAware) {
+    let reference;
+    if (this.isReferenceString(schemaAware.schema)) {
+      reference = new ReferenceBuilder().build(schemaAware.schema);
+    }
+    return {
+      reference,
+      body: this.buildBody(schemaAware, reference)
+    };
+  }
+  getOpenApiSchemaFromApexDocSchema(schemaAware, reference) {
+    if (this.isReferenceString(schemaAware.schema)) {
+      return reference.entrypointReferenceObject;
+    }
+    return schemaAware.schema;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+class ParameterObjectBuilder extends Builder {
+  buildBody(apexDocObject, reference) {
+    return __spreadProps$1(__spreadValues$1({}, apexDocObject), {
+      schema: this.getOpenApiSchemaFromApexDocSchema(apexDocObject, reference)
+    });
+  }
+}
+
+class ResponsesBuilder extends Builder {
+  buildBody(apexDocResponseDefinition, reference) {
+    let description = `Status code ${apexDocResponseDefinition.statusCode}`;
+    if (apexDocResponseDefinition.description) {
+      description = apexDocResponseDefinition.description;
+    }
+    return {
+      description,
+      content: {
+        "application/json": {
+          schema: this.getOpenApiSchemaFromApexDocSchema(apexDocResponseDefinition, reference)
+        }
+      }
+    };
+  }
+}
+
+class RequestBodyBuilder extends Builder {
+  buildBody(apexRequestBody, reference) {
+    return {
+      description: apexRequestBody.description,
+      content: {
+        "application/json": { schema: this.getOpenApiSchemaFromApexDocSchema(apexRequestBody, reference) }
+      },
+      required: apexRequestBody.required
+    };
+  }
+}
+
+class MethodMirrorWrapper {
+  constructor(methodMirror) {
+    this.methodMirror = methodMirror;
+    this.hasDocCommentAnnotation = (annotationName) => {
+      var _a;
+      return (_a = this.methodMirror.docComment) == null ? void 0 : _a.annotations.some((annotation) => annotation.name.toLowerCase() === annotationName);
+    };
+    this.getDocCommentAnnotation = (annotationName) => {
+      var _a;
+      return (_a = this.methodMirror.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === annotationName);
+    };
+  }
+}
+
+class MethodParser {
+  constructor(openApiModel) {
+    this.openApiModel = openApiModel;
+  }
+  parseMethod(classMirror, httpUrlEndpoint, httpMethodKey, tag) {
+    var _a, _b;
+    const classMirrorWrapper = new ClassMirrorWrapper(classMirror);
+    const httpMethods = classMirrorWrapper.getMethodsByAnnotation(`http${httpMethodKey}`);
+    if (!httpMethods.length) {
+      return;
+    }
+    const httpMethod = httpMethods[0];
+    this.openApiModel.paths[httpUrlEndpoint][httpMethodKey] = {};
+    this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].tags = [tag];
+    if ((_a = httpMethod.docComment) == null ? void 0 : _a.description) {
+      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].description = httpMethod.docComment.description;
+    }
+    const methodMirrorWrapper = new MethodMirrorWrapper(httpMethod);
+    if (methodMirrorWrapper.hasDocCommentAnnotation("summary")) {
+      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].summary = (_b = methodMirrorWrapper.getDocCommentAnnotation("summary")) == null ? void 0 : _b.body;
+    }
+    this.parseHttpAnnotation(
+      httpMethod,
+      httpUrlEndpoint,
+      httpMethodKey,
+      "http-request-body",
+      this.addRequestBodyToOpenApi.bind(this),
+      this.fallbackHttpRequestBodyParser(httpUrlEndpoint, httpMethodKey)
+    );
+    this.parseHttpAnnotation(
+      httpMethod,
+      httpUrlEndpoint,
+      httpMethodKey,
+      "http-parameter",
+      this.addParametersToOpenApi.bind(this)
+    );
+    this.parseHttpAnnotation(
+      httpMethod,
+      httpUrlEndpoint,
+      httpMethodKey,
+      "http-response",
+      this.addHttpResponsesToOpenApi.bind(this),
+      this.getFallbackHttpResponseParser(httpUrlEndpoint, httpMethodKey)
+    );
+  }
+  parseHttpAnnotation(httpMethod, urlValue, httpMethodKey, annotationName, addToOpenApi, fallbackParser) {
+    var _a;
+    const annotations = (_a = httpMethod.docComment) == null ? void 0 : _a.annotations.filter((annotation) => annotation.name === annotationName);
+    if (!(annotations == null ? void 0 : annotations.length)) {
+      if (fallbackParser) {
+        fallbackParser(httpMethod);
+      }
+      return;
+    }
+    for (const annotation of annotations) {
+      const inYaml = annotation == null ? void 0 : annotation.bodyLines.reduce((prev, current) => prev + "\n" + current);
+      if (!inYaml) {
+        return;
+      }
+      this.addToOpenApiStrategy(inYaml, urlValue, httpMethodKey, addToOpenApi);
+    }
+  }
+  addToOpenApiStrategy(inYaml, urlValue, httpMethodKey, addToOpenApi) {
+    const inJson = yaml__namespace.load(inYaml);
+    const requestBodyResponse = new RequestBodyBuilder().build(inJson);
+    addToOpenApi(inJson, urlValue, httpMethodKey);
+    this.addReference(requestBodyResponse);
+  }
+  addRequestBodyToOpenApi(input, urlValue, httpMethodKey) {
+    const requestBodyResponse = new RequestBodyBuilder().build(input);
+    this.openApiModel.paths[urlValue][httpMethodKey].requestBody = requestBodyResponse.body;
+  }
+  addParametersToOpenApi(input, urlValue, httpMethodKey) {
+    const parameterObjectResponse = new ParameterObjectBuilder().build(input);
+    if (this.openApiModel.paths[urlValue][httpMethodKey].parameters === void 0) {
+      this.openApiModel.paths[urlValue][httpMethodKey].parameters = [];
+    }
+    this.openApiModel.paths[urlValue][httpMethodKey].parameters.push(parameterObjectResponse.body);
+  }
+  addHttpResponsesToOpenApi(input, urlValue, httpMethodKey) {
+    const responseObjectResponse = new ResponsesBuilder().build(input);
+    if (this.openApiModel.paths[urlValue][httpMethodKey].responses === void 0) {
+      this.openApiModel.paths[urlValue][httpMethodKey].responses = {};
+    }
+    this.openApiModel.paths[urlValue][httpMethodKey].responses[input.statusCode] = responseObjectResponse.body;
+  }
+  fallbackHttpRequestBodyParser(httpUrlEndpoint, httpMethodKey) {
+    return (methodMirror) => {
+      const parameters = methodMirror.parameters;
+      if (!parameters.length) {
+        return;
+      }
+      const propertiesObject = {};
+      parameters.forEach((currentParameter) => {
+        const propertyKey = currentParameter.name;
+        const propertyReference = new ReferenceBuilder().getReferenceType(currentParameter.typeReference);
+        propertiesObject[propertyKey] = propertyReference.schema;
+        this.addReference({
+          reference: {
+            entrypointReferenceObject: propertyReference.schema,
+            referenceComponents: propertyReference.referenceComponents
+          }
+        });
+      });
+      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].requestBody = {
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: propertiesObject
+            }
+          }
+        }
+      };
+    };
+  }
+  getFallbackHttpResponseParser(httpUrlEndpoint, httpMethodKey) {
+    return (methodMirror) => {
+      var _a, _b;
+      const returnType = methodMirror.typeReference;
+      if (returnType.type.toLowerCase() === "void") {
+        return;
+      }
+      const reference = new ReferenceBuilder().getReferenceType(returnType);
+      this.addReference({
+        reference: {
+          entrypointReferenceObject: reference.schema,
+          referenceComponents: reference.referenceComponents
+        }
+      });
+      if (this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses === void 0) {
+        this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses = {};
+      }
+      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses["200"] = {
+        description: (_b = (_a = methodMirror.docComment) == null ? void 0 : _a.description) != null ? _b : "Status code 200",
+        content: {
+          "application/json": { schema: reference.schema }
+        }
+      };
+    };
+  }
+  addReference(referenceHolder) {
+    if (referenceHolder.reference) {
+      if (this.openApiModel.components === void 0) {
+        this.openApiModel.components = {
+          schemas: {}
+        };
+      }
+      if (!referenceHolder.reference.referenceComponents.length) {
+        return;
+      }
+      referenceHolder.reference.referenceComponents.forEach((current) => {
+        this.openApiModel.components.schemas[current.referencedClass] = current.schema;
+      });
+    }
+  }
+}
+
+const camel2title = (camelCase) => camelCase.replace(/\//g, " ").replace(/([A-Z])/g, (match) => ` ${match}`).replace(/\b\w/g, (match) => match.toUpperCase()).replace(/^./, (match) => match.toUpperCase()).trim();
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function createOpenApiFile(fileName, openApiModel) {
+  const content = JSON.stringify(__spreadProps(__spreadValues({}, openApiModel), { namespace: void 0 }), null, 2);
+  return {
+    outputDocPath: `${fileName}.json`,
+    content,
+    frontmatter: null,
+    group: null
+  };
+}
+
+class OpenApiDocsProcessor {
+  constructor(logger) {
+    this.logger = logger;
+    this.onAfterProcess = () => {
+      const page = createOpenApiFile(OpenApiSettings.getInstance().openApiFileName(), this.openApiModel);
+      this._fileContainer.pushFile(page);
+    };
+    this._fileContainer = new FileContainer();
+    const title = OpenApiSettings.getInstance().getOpenApiTitle();
+    if (!title) {
+      throw Error("No OpenApi title was provided.");
+    }
+    this.openApiModel = new OpenApi(
+      title,
+      OpenApiSettings.getInstance().getVersion(),
+      OpenApiSettings.getInstance().getNamespace()
+    );
+  }
+  fileBuilder() {
+    return this._fileContainer;
+  }
+  onProcess(type) {
+    var _a, _b;
+    this.logger.logSingle(`Processing ${type.name}`, "green");
+    const endpointPath = this.getEndpointPath(type);
+    if (!endpointPath) {
+      return;
+    }
+    this.openApiModel.paths[endpointPath] = {};
+    if ((_a = type.docComment) == null ? void 0 : _a.description) {
+      this.openApiModel.paths[endpointPath].description = type.docComment.description;
+    }
+    const typeAsClass = type;
+    const tagName = camel2title(endpointPath);
+    this.openApiModel.tags.push({
+      name: tagName,
+      description: (_b = type.docComment) == null ? void 0 : _b.description
+    });
+    const parser = new MethodParser(this.openApiModel);
+    parser.parseMethod(typeAsClass, endpointPath, "get", tagName);
+    parser.parseMethod(typeAsClass, endpointPath, "patch", tagName);
+    parser.parseMethod(typeAsClass, endpointPath, "post", tagName);
+    parser.parseMethod(typeAsClass, endpointPath, "put", tagName);
+    parser.parseMethod(typeAsClass, endpointPath, "delete", tagName);
+  }
+  getEndpointPath(type) {
+    var _a;
+    const restResourceAnnotation = type.annotations.find((element) => element.name.toLowerCase() === "restresource");
+    const urlMapping = (_a = restResourceAnnotation == null ? void 0 : restResourceAnnotation.elementValues) == null ? void 0 : _a.find(
+      (element) => element.key.toLowerCase() === "urlmapping"
+    );
+    if (!urlMapping) {
+      this.logger.error(`Type does not contain urlMapping annotation ${type.name}`);
+      return null;
+    }
+    let endpointPath = urlMapping.value.replaceAll('"', "").replaceAll("'", "").replaceAll("/*", "/");
+    if (endpointPath.startsWith("/")) {
+      endpointPath = endpointPath.substring(1);
+    }
+    return endpointPath;
+  }
+}
+
+var __async$3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function openApi(logger, fileBodies, config) {
+  return __async$3(this, null, function* () {
+    OpenApiSettings.build({
+      sourceDirectory: config.sourceDir,
+      outputDir: config.targetDir,
+      openApiFileName: config.fileName,
+      openApiTitle: config.title,
+      namespace: config.namespace,
+      version: config.apiVersion
+    });
+    const manifest = createManifest(new RawBodyParser(logger, fileBodies), apply(reflectionWithLogger, logger));
+    TypesRepository.getInstance().populateAll(manifest.types);
+    const filteredTypes = filterByScopes(logger, manifest);
+    const processor = new OpenApiDocsProcessor(logger);
+    Transpiler.generate(filteredTypes, processor);
+    const generatedFiles = processor.fileBuilder().files();
+    yield _function.pipe(
+      writeFiles(generatedFiles, config.targetDir, (file) => {
+        logger.logSingle(`${file.outputDocPath} processed.`, "green");
+      }),
+      TE__namespace.mapError((error) => logger.error(error))
+    )();
+    ErrorLogger.logErrors(logger, filteredTypes);
+  });
+}
+function reflectionWithLogger(logger, apexBundle) {
+  var _a;
+  const result = apexReflection.reflect(apexBundle.content);
+  if (result.error) {
+    logger.error(`${apexBundle.filePath} - Parsing error ${(_a = result.error) == null ? void 0 : _a.message}`);
+  }
+  return result;
+}
+function filterByScopes(logger, manifest) {
+  const filteredTypes = manifest.filteredByAccessModifierAndAnnotations([
+    "restresource",
+    "httpdelete",
+    "httpget",
+    "httppatch",
+    "httppost",
+    "httpput"
+  ]);
+  const filteredLogMessage = `Filtered ${manifest.types.length - filteredTypes.length} file(s), only keeping classes annotated as @RestResource.`;
+  logger.logSingle(filteredLogMessage, "green");
+  logger.logSingle(`Creating documentation for ${filteredTypes.length} file(s)`, "green");
+  return filteredTypes;
+}
+
+function areMethodsEqual(method1, method2) {
+  if (method1.name.toLowerCase() !== method2.name.toLowerCase()) {
+    return false;
+  }
+  if (method1.typeReference.rawDeclaration.toLowerCase() !== method2.typeReference.rawDeclaration.toLowerCase()) {
+    return false;
+  }
+  if (method1.parameters.length !== method2.parameters.length) {
+    return false;
+  }
+  for (let i = 0; i < method1.parameters.length; i++) {
+    if (method1.parameters[i].typeReference.rawDeclaration.toLowerCase() !== method2.parameters[i].typeReference.rawDeclaration.toLowerCase()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function processChangelog(oldVersion, newVersion) {
+  return {
+    newTypes: getNewTypes(oldVersion, newVersion),
+    removedTypes: getRemovedTypes(oldVersion, newVersion),
+    newOrModifiedMembers: getNewOrModifiedMembers(oldVersion, newVersion)
+  };
+}
+function getNewTypes(oldVersion, newVersion) {
+  return newVersion.types.filter((newType) => !oldVersion.types.some((oldType) => oldType.name.toLowerCase() === newType.name.toLowerCase())).map((type) => type.name);
+}
+function getRemovedTypes(oldVersion, newVersion) {
+  return oldVersion.types.filter((oldType) => !newVersion.types.some((newType) => newType.name.toLowerCase() === oldType.name.toLowerCase())).map((type) => type.name);
+}
+function getNewOrModifiedMembers(oldVersion, newVersion) {
+  return _function.pipe(
+    getTypesInBothVersions(oldVersion, newVersion),
+    (typesInBoth) => [
+      ...getNewOrModifiedEnumValues(typesInBoth),
+      ...getNewOrModifiedMethods(typesInBoth),
+      ...getNewOrModifiedClassMembers(typesInBoth)
+    ],
+    (newOrModifiedMembers) => newOrModifiedMembers.filter((member) => member.modifications.length > 0)
+  );
+}
+function getNewOrModifiedEnumValues(typesInBoth) {
+  return _function.pipe(
+    typesInBoth.filter((typeInBoth) => typeInBoth.oldType.type_name === "enum"),
+    (enumsInBoth) => enumsInBoth.map(({ oldType, newType }) => {
+      const oldEnum = oldType;
+      const newEnum = newType;
+      return {
+        typeName: newType.name,
+        modifications: [
+          ...getNewValues(oldEnum, newEnum, "values", "NewEnumValue"),
+          ...getRemovedValues(oldEnum, newEnum, "values", "RemovedEnumValue")
+        ]
+      };
+    })
+  );
+}
+function getNewOrModifiedMethods(typesInBoth) {
+  return _function.pipe(
+    typesInBoth.filter(
+      (typeInBoth) => typeInBoth.oldType.type_name === "class" || typeInBoth.oldType.type_name === "interface"
+    ),
+    (typesInBoth2) => typesInBoth2.map(({ oldType, newType }) => {
+      const oldMethodAware = oldType;
+      const newMethodAware = newType;
+      return {
+        typeName: newType.name,
+        modifications: [
+          ...getNewValues(
+            oldMethodAware,
+            newMethodAware,
+            "methods",
+            "NewMethod",
+            areMethodsEqual
+          ),
+          ...getRemovedValues(
+            oldMethodAware,
+            newMethodAware,
+            "methods",
+            "RemovedMethod",
+            areMethodsEqual
+          )
+        ]
+      };
+    })
+  );
+}
+function getNewOrModifiedClassMembers(typesInBoth) {
+  return _function.pipe(
+    typesInBoth.filter((typeInBoth) => typeInBoth.oldType.type_name === "class"),
+    (classesInBoth) => classesInBoth.map(({ oldType, newType }) => {
+      const oldClass = oldType;
+      const newClass = newType;
+      return {
+        typeName: newType.name,
+        modifications: [
+          ...getNewValues(oldClass, newClass, "properties", "NewProperty"),
+          ...getRemovedValues(oldClass, newClass, "properties", "RemovedProperty"),
+          ...getNewValues(oldClass, newClass, "fields", "NewField"),
+          ...getRemovedValues(oldClass, newClass, "fields", "RemovedField"),
+          ...getNewValues(oldClass, newClass, "classes", "NewType"),
+          ...getRemovedValues(oldClass, newClass, "classes", "RemovedType"),
+          ...getNewValues(oldClass, newClass, "interfaces", "NewType"),
+          ...getRemovedValues(oldClass, newClass, "interfaces", "RemovedType"),
+          ...getNewValues(oldClass, newClass, "enums", "NewType"),
+          ...getRemovedValues(oldClass, newClass, "enums", "RemovedType")
+        ]
+      };
+    })
+  );
+}
+function getTypesInBothVersions(oldVersion, newVersion) {
+  return oldVersion.types.map((oldType) => ({
+    oldType,
+    newType: newVersion.types.find((newType) => newType.name.toLowerCase() === oldType.name.toLowerCase())
+  })).filter((type) => type.newType !== void 0);
+}
+function areEqualByName(oldValue, newValue) {
+  return oldValue.name.toLowerCase() === newValue.name.toLowerCase();
+}
+function getNewValues(oldPlaceToSearch, newPlaceToSearch, keyToSearch, typeName, areEqualFn = areEqualByName) {
+  return newPlaceToSearch[keyToSearch].filter((newValue) => !oldPlaceToSearch[keyToSearch].some((oldValue) => areEqualFn(oldValue, newValue))).map((value) => value.name).map((name) => ({ __typename: typeName, name }));
+}
+function getRemovedValues(oldPlaceToSearch, newPlaceToSearch, keyToSearch, typeName, areEqualFn = areEqualByName) {
+  return oldPlaceToSearch[keyToSearch].filter((oldValue) => !newPlaceToSearch[keyToSearch].some((newValue) => areEqualFn(oldValue, newValue))).map((value) => value.name).map((name) => ({ __typename: typeName, name }));
+}
+
+function convertToRenderableChangelog(changelog, newManifest) {
+  const allNewTypes = changelog.newTypes.map(
+    (newType) => newManifest.find((type) => type.name.toLowerCase() === newType.toLowerCase())
+  );
+  const newClasses = allNewTypes.filter((type) => type.type_name === "class");
+  const newInterfaces = allNewTypes.filter((type) => type.type_name === "interface");
+  const newEnums = allNewTypes.filter((type) => type.type_name === "enum");
+  return {
+    newClasses: newClasses.length > 0 ? {
+      __type: "class",
+      heading: "New Classes",
+      description: "These classes are new.",
+      types: newClasses.map(typeToRenderable)
+    } : null,
+    newInterfaces: newInterfaces.length > 0 ? {
+      __type: "interface",
+      heading: "New Interfaces",
+      description: "These interfaces are new.",
+      types: newInterfaces.map(typeToRenderable)
+    } : null,
+    newEnums: newEnums.length > 0 ? {
+      __type: "enum",
+      heading: "New Enums",
+      description: "These enums are new.",
+      types: newEnums.map(typeToRenderable)
+    } : null,
+    removedTypes: changelog.removedTypes.length > 0 ? { heading: "Removed Types", description: "These types have been removed.", types: changelog.removedTypes } : null,
+    newOrModifiedMembers: changelog.newOrModifiedMembers.length > 0 ? {
+      heading: "New or Modified Members in Existing Types",
+      description: "These members have been added or modified.",
+      modifications: changelog.newOrModifiedMembers.map(toRenderableModification)
+    } : null
+  };
+}
+function typeToRenderable(type) {
+  function adapt() {
+    var _a;
+    const describable = adaptDescribable((_a = type.docComment) == null ? void 0 : _a.descriptionLines, (typeName) => typeName);
+    return describable.description;
+  }
+  return {
+    name: type.name,
+    description: adapt()
+  };
+}
+function toRenderableModification(newOrModifiedMember) {
+  return {
+    typeName: newOrModifiedMember.typeName,
+    modifications: newOrModifiedMember.modifications.map(toRenderableModificationDescription)
+  };
+}
+function toRenderableModificationDescription(memberModificationType) {
+  switch (memberModificationType.__typename) {
+    case "NewEnumValue":
+      return `New Enum Value: ${memberModificationType.name}`;
+    case "RemovedEnumValue":
+      return `Removed Enum Value: ${memberModificationType.name}`;
+    case "NewMethod":
+      return `New Method: ${memberModificationType.name}`;
+    case "RemovedMethod":
+      return `Removed Method: ${memberModificationType.name}`;
+    case "NewProperty":
+      return `New Property: ${memberModificationType.name}`;
+    case "RemovedProperty":
+      return `Removed Property: ${memberModificationType.name}`;
+    case "NewField":
+      return `New Field: ${memberModificationType.name}`;
+    case "RemovedField":
+      return `Removed Field: ${memberModificationType.name}`;
+    case "NewType":
+      return `New Type: ${memberModificationType.name}`;
+    case "RemovedType":
+      return `Removed Type: ${memberModificationType.name}`;
+  }
+}
+
+const changelogTemplate = `
+# Changelog
+
+{{#if newClasses}}
+## {{newClasses.heading}}
+
+{{newClasses.description}}
+
+{{#each newClasses.types}}
+### {{this.name}}
+
+{{{renderContent this.description}}}
+{{/each}}
+{{/if}}
+
+{{#if newInterfaces}}
+## {{newInterfaces.heading}}
+
+{{newInterfaces.description}}
+
+{{#each newInterfaces.types}}
+### {{this.name}}
+
+{{{renderContent this.description}}}
+{{/each}}
+{{/if}}
+
+{{#if newEnums}}
+## {{newEnums.heading}}
+
+{{newEnums.description}}
+
+{{#each newEnums.types}}
+### {{this.name}}
+
+{{{renderContent this.description}}}
+{{/each}}
+{{/if}}
+
+{{#if removedTypes}}
+## Removed Types
+
+{{removedTypes.description}}
+
+{{#each removedTypes.types}}
+- {{this}}
+{{/each}}
+{{/if}}
+
+{{#if newOrModifiedMembers}}
+## {{newOrModifiedMembers.heading}}
+
+{{newOrModifiedMembers.description}}
+
+{{#each newOrModifiedMembers.modifications}}
+### {{this.typeName}}
+
+{{#each this.modifications}}
+- {{this}}
+{{/each}}
+{{/each}}
+{{/if}}
+`.trim();
+
+function generateChangeLog(oldBundles, newBundles, config) {
+  const filterOutOfScope = apply(filterScope, config.scope);
+  function reflect(sourceFiles) {
+    return _function.pipe(reflectBundles(sourceFiles), TE__namespace.map(filterOutOfScope));
+  }
+  const convertToPageData = apply(toPageData, config.fileName);
+  return _function.pipe(
+    reflect(oldBundles),
+    TE__namespace.bindTo("oldVersion"),
+    TE__namespace.bind("newVersion", () => reflect(newBundles)),
+    TE__namespace.map(toManifests),
+    TE__namespace.map(({ oldManifest, newManifest }) => ({
+      changeLog: processChangelog(oldManifest, newManifest),
+      newManifest
+    })),
+    TE__namespace.map(({ changeLog, newManifest }) => convertToRenderableChangelog(changeLog, newManifest.types)),
+    TE__namespace.map(compile),
+    TE__namespace.map(convertToPageData)
+  );
+}
+function toManifests({ oldVersion, newVersion }) {
+  function parsedFilesToManifest(parsedFiles) {
+    return {
+      types: parsedFiles.map((parsedFile) => parsedFile.type)
+    };
+  }
+  return {
+    oldManifest: parsedFilesToManifest(oldVersion),
+    newManifest: parsedFilesToManifest(newVersion)
+  };
+}
+function compile(renderable) {
+  const compilationRequest = {
+    template: changelogTemplate,
+    source: renderable
+  };
+  return Template.getInstance().compile(compilationRequest);
+}
+function toPageData(fileName, content) {
+  return {
+    content,
+    outputDocPath: `${fileName}.md`
+  };
+}
+
+function generate(oldBundles, newBundles, config) {
+  return _function.pipe(
+    generateChangeLog(oldBundles, newBundles, config),
+    TE__namespace.flatMap((files) => writeFilesToSystem(files, config.targetDir))
+  );
+}
+function writeFilesToSystem(pageData, outputDir) {
+  return _function.pipe(
+    [pageData],
+    (files) => writeFiles(files, outputDir),
+    TE__namespace.mapLeft((error) => {
+      return new FileWritingError("An error occurred while writing files to the system.", error);
+    })
+  );
+}
+
+var __async$2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const APEX_FILE_EXTENSION = ".cls";
+function processFiles(fileSystem, rootPath, includeMetadata, exclude) {
+  return __async$2(this, null, function* () {
+    const processSingleFile = apply(processFile, fileSystem, includeMetadata);
+    return _function.pipe(
+      yield getFilePaths(fileSystem, rootPath),
+      (filePaths) => filePaths.filter((filePath) => !isExcluded(filePath, exclude)),
+      (filePaths) => filePaths.filter(isApexFile),
+      (filePaths) => Promise.all(filePaths.map(processSingleFile))
+    );
+  });
+}
+function getFilePaths(fileSystem, rootPath) {
+  return __async$2(this, null, function* () {
+    const directoryContents = yield fileSystem.readDirectory(rootPath);
+    const paths = [];
+    for (const filePath of directoryContents) {
+      const currentPath = fileSystem.joinPath(rootPath, filePath);
+      if (yield fileSystem.isDirectory(currentPath)) {
+        paths.push(...yield getFilePaths(fileSystem, currentPath));
+      } else {
+        paths.push(currentPath);
+      }
+    }
+    return paths;
+  });
+}
+function isExcluded(filePath, exclude) {
+  return exclude.some((pattern) => minimatch.minimatch(filePath, pattern));
+}
+function processFile(fileSystem, includeMetadata, filePath) {
+  return __async$2(this, null, function* () {
+    const rawTypeContent = yield fileSystem.readFile(filePath);
+    const metadataPath = `${filePath}-meta.xml`;
+    let rawMetadataContent = null;
+    if (includeMetadata) {
+      rawMetadataContent = fileSystem.exists(metadataPath) ? yield fileSystem.readFile(metadataPath) : null;
+    }
+    return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
+  });
+}
+function isApexFile(currentFile) {
+  return currentFile.endsWith(APEX_FILE_EXTENSION);
+}
+
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function stat(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.stat(path2, (err, stats) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}
+function readdir(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readdir(path2, (err, files) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(files);
+      }
+    });
+  });
+}
+function readFile(path2) {
+  return new Promise((resolve, reject) => {
+    fs__namespace.readFile(path2, (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+}
+class DefaultFileSystem {
+  isDirectory(pathToRead) {
+    return __async$1(this, null, function* () {
+      const stats = yield stat(pathToRead);
+      return stats.isDirectory();
+    });
+  }
+  readDirectory(sourceDirectory) {
+    return readdir(sourceDirectory);
+  }
+  readFile(pathToRead) {
+    return readFile(pathToRead);
+  }
+  joinPath(...paths) {
+    return path__namespace.join(...paths);
+  }
+  exists(path2) {
+    return fs__namespace.existsSync(path2);
+  }
+}
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class Apexdocs {
+  /**
+   * Generates documentation out of Apex source files.
+   */
+  static generate(config, logger) {
+    return __async(this, null, function* () {
+      logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
+      try {
+        switch (config.targetGenerator) {
+          case "markdown":
+            return (yield processMarkdown(config))();
+          case "openapi":
+            yield processOpenApi(config, logger);
+            return E__namespace.right("\u2714\uFE0F Documentation generated successfully!");
+          case "changelog":
+            return (yield processChangeLog(config))();
+        }
+      } catch (error) {
+        return E__namespace.left([error]);
+      }
+    });
+  }
+}
+const readFiles = apply(processFiles, new DefaultFileSystem());
+function processMarkdown(config) {
+  return __async(this, null, function* () {
+    return _function.pipe(
+      TE__namespace.tryCatch(
+        () => readFiles(config.sourceDir, config.includeMetadata, config.exclude),
+        (e) => new FileReadingError("An error occurred while reading files.", e)
+      ),
+      TE__namespace.flatMap((fileBodies) => generate$1(fileBodies, config)),
+      TE__namespace.map(() => "\u2714\uFE0F Documentation generated successfully!"),
+      TE__namespace.mapLeft(toErrors)
+    );
+  });
+}
+function processOpenApi(config, logger) {
+  return __async(this, null, function* () {
+    const fileBodies = yield readFiles(config.sourceDir, false, config.exclude);
+    return openApi(logger, fileBodies, config);
+  });
+}
+function processChangeLog(config) {
+  return __async(this, null, function* () {
+    function loadFiles() {
+      return __async(this, null, function* () {
+        return [
+          yield readFiles(config.previousVersionDir, false, config.exclude),
+          yield readFiles(config.currentVersionDir, false, config.exclude)
+        ];
+      });
+    }
+    return _function.pipe(
+      TE__namespace.tryCatch(loadFiles, (e) => new FileReadingError("An error occurred while reading files.", e)),
+      TE__namespace.flatMap(([previous, current]) => generate(previous, current, config)),
+      TE__namespace.map(() => "\u2714\uFE0F Changelog generated successfully!"),
+      TE__namespace.mapLeft(toErrors)
+    );
+  });
+}
+function toErrors(error) {
+  switch (error._tag) {
+    case "HookError":
+      return ["Error(s) occurred while processing hooks. Please review the following issues:", error.error];
+    case "FileReadingError":
+      return ["Error(s) occurred while reading files. Please review the following issues:", error.error];
+    case "FileWritingError":
+      return ["Error(s) occurred while writing files. Please review the following issues:", error.error];
+    default:
+      return [
+        "Error(s) occurred while parsing files. Please review the following issues:",
+        ...error.errors.map(formatReflectionError)
+      ];
+  }
+}
+function formatReflectionError(error) {
+  return `Source file: ${error.file}
+${error.message}
+`;
+}
+
+class StdOutLogger {
+  /**
+   * Logs a message with optional arguments.
+   * @param message The message to log.
+   * @param args Optional arguments.
+   */
+  log(message, ...args) {
+    this.logSingle(message);
+    args.forEach((arg) => {
+      this.logSingle(arg);
+    });
+  }
+  /**
+   * Logs an error message with optional arguments.
+   * @param message The error message to log.
+   * @param args Optional arguments.
+   */
+  error(message, ...args) {
+    this.logSingle(message, "red");
+    args.forEach(() => {
+      this.logSingle(message, "red");
+    });
+  }
+  logSingle(text, color = "green") {
+    const logMessage = `${this.getChalkFn(color)((/* @__PURE__ */ new Date()).toLocaleString() + ": ")}${text}
+`;
+    process.stdout.write(logMessage);
+  }
+  getChalkFn(color) {
+    return color === "green" ? chalk.green : chalk.red;
+  }
+}
+class NoLogger {
+  log() {
+  }
+  error() {
+  }
+  logSingle() {
+  }
+}
+
+exports.Apexdocs = Apexdocs;
+exports.NoLogger = NoLogger;
+exports.StdOutLogger = StdOutLogger;
+exports.changeLogDefaults = changeLogDefaults;
+exports.markdownDefaults = markdownDefaults;
+exports.openApiDefaults = openApiDefaults;