@diplodoc/cli 4.0.0

package/build/index.js

@@ -0,0 +1,3993 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name4 in all)
+    __defProp(target, name4, { get: all[name4], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve17, 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 ? resolve17(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// scripts/client.js
+var require_client = __commonJS({
+  "scripts/client.js"(exports, module2) {
+    "use strict";
+    var path = require("path");
+    var CLIENT_PATH = path.dirname(require.resolve("@diplodoc/client"));
+    var BUILD_PATH = path.resolve(__dirname, "..", "build");
+    var BUNDLE_JS_FILENAME = "app.client.js";
+    var BUNDLE_CSS_FILENAME = "app.client.css";
+    var src = (target) => path.resolve(CLIENT_PATH, target);
+    var dst = (target) => path.resolve(BUILD_PATH, target);
+    module2.exports = {
+      dst: {
+        js: dst(BUNDLE_JS_FILENAME),
+        css: dst(BUNDLE_CSS_FILENAME)
+      },
+      src: {
+        js: src(BUNDLE_JS_FILENAME),
+        css: src(BUNDLE_CSS_FILENAME)
+      },
+      bundle: {
+        js(bundlePath) {
+          return path.join(bundlePath, BUNDLE_JS_FILENAME);
+        },
+        css(bundlePath) {
+          return path.join(bundlePath, BUNDLE_CSS_FILENAME);
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var import_log14 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_register = require("threads/register");
+
+// src/constants.ts
+var import_path = require("path");
+var os = require("os");
+var notes = require("@doc-tools/transform/lib/plugins/notes");
+var anchors = require("@doc-tools/transform/lib/plugins/anchors");
+var code = require("@doc-tools/transform/lib/plugins/code");
+var cut = require("@doc-tools/transform/lib/plugins/cut");
+var deflist = require("@doc-tools/transform/lib/plugins/deflist");
+var imsize = require("@doc-tools/transform/lib/plugins/imsize");
+var meta = require("@doc-tools/transform/lib/plugins/meta");
+var sup = require("@doc-tools/transform/lib/plugins/sup");
+var tabs = require("@doc-tools/transform/lib/plugins/tabs");
+var video = require("@doc-tools/transform/lib/plugins/video");
+var includes = require("@doc-tools/transform/lib/plugins/includes");
+var links = require("@doc-tools/transform/lib/plugins/links");
+var images = require("@doc-tools/transform/lib/plugins/images");
+var monospace = require("@doc-tools/transform/lib/plugins/monospace");
+var table = require("@doc-tools/transform/lib/plugins/table");
+var term = require("@doc-tools/transform/lib/plugins/term");
+var changelog = require("@doc-tools/transform/lib/plugins/changelog");
+var mermaid = require("@diplodoc/mermaid-extension");
+var openapi = require("@diplodoc/openapi-extension");
+includes.collect = require("@doc-tools/transform/lib/plugins/includes/collect");
+images.collect = require("@doc-tools/transform/lib/plugins/images/collect");
+changelog.collect = require("@doc-tools/transform/lib/plugins/changelog/collect");
+var BUNDLE_FOLDER = "_bundle";
+var TMP_INPUT_FOLDER = ".tmp_input";
+var TMP_OUTPUT_FOLDER = ".tmp_output";
+var MAIN_TIMER_ID = "Build time";
+var YFM_CONFIG_FILENAME = ".yfm";
+var REDIRECTS_FILENAME = "redirects.yaml";
+var LINT_CONFIG_FILENAME = ".yfmlint";
+var SINGLE_PAGE_FILENAME = "single-page.html";
+var SINGLE_PAGE_DATA_FILENAME = "single-page.json";
+var CUSTOM_STYLE = "custom-style";
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["style"] = "style";
+  ResourceType2["script"] = "script";
+  return ResourceType2;
+})(ResourceType || {});
+var BUILD_FOLDER_PATH = (0, import_path.dirname)(require.resolve("@diplodoc/client"));
+var YFM_PLUGINS = [
+  meta,
+  deflist,
+  includes,
+  cut,
+  links,
+  images,
+  notes,
+  anchors,
+  tabs,
+  code,
+  imsize,
+  sup,
+  video,
+  monospace,
+  table,
+  term,
+  openapi.transform(),
+  mermaid.transform(),
+  changelog
+];
+var PROCESSING_FINISHED = "Processing finished:";
+var LINTING_FINISHED = "Linting finished:";
+var GETTING_ALL_CONTRIBUTORS = "Getting all contributors.";
+var ALL_CONTRIBUTORS_RECEIVED = "All contributors received.";
+var getMsg\u0421onfigurationMustBeProvided = (repo) => `\u0421onfiguration must be provided for ${repo} like env variables or in .yfm file`;
+var FIRST_COMMIT_FROM_ROBOT_IN_GITHUB = "2dce14271359cd20d7e874956d604de087560cf4";
+var REGEXP_INCLUDE_CONTENTS = new RegExp("(?<=[{%]\\sinclude\\s).+(?=\\s[%}])", "gm");
+var REGEXP_INCLUDE_FILE_PATH = new RegExp("(?<=[(]).+(?=[)])", "g");
+var REGEXP_AUTHOR = new RegExp("(?<=author:\\s).+(?=\\r?\\n)", "g");
+var MIN_CHUNK_SIZE = Number(process.env.MIN_CHUNK_SIZE) || 1e3;
+var WORKERS_COUNT = Number(process.env.WORKERS_COUNT) || os.cpus().length - 1;
+var metadataBorder = "---";
+
+// src/validator.ts
+var import_path2 = require("path");
+var import_fs = require("fs");
+var import_js_yaml = require("js-yaml");
+var import_merge = __toESM(require("lodash/merge"));
+var import_log = __toESM(require("@doc-tools/transform/lib/log"));
+function notEmptyStringValidator(value) {
+  if (typeof value === "string") {
+    return Boolean(value);
+  }
+  return false;
+}
+function requiredValueValidator(value) {
+  return Boolean(value);
+}
+var validators = {
+  "storageEndpoint": {
+    errorMessage: "Endpoint of S3 storage must be provided when publishes.",
+    validateFn: notEmptyStringValidator
+  },
+  "storageBucket": {
+    errorMessage: "Bucket name of S3 storage must be provided when publishes.",
+    validateFn: notEmptyStringValidator
+  },
+  "storageKeyId": {
+    errorMessage: "Key Id of S3 storage must be provided when publishes.",
+    validateFn: notEmptyStringValidator,
+    defaultValue: process.env.YFM_STORAGE_KEY_ID
+  },
+  "storageSecretKey": {
+    errorMessage: "Secret key of S3 storage must be provided when publishes.",
+    validateFn: notEmptyStringValidator,
+    defaultValue: process.env.YFM_STORAGE_SECRET_KEY
+  },
+  "storageRegion": {
+    errorMessage: "Region of S3 storage must be provided when publishes.",
+    validateFn: notEmptyStringValidator,
+    defaultValue: "eu-central-1"
+  }
+};
+function validateRedirects(redirectsConfig, pathToRedirects) {
+  const redirects = Object.keys(redirectsConfig).reduce((res, redirectSectionName) => {
+    const sectionRedirects = redirectsConfig[redirectSectionName];
+    res.push(...sectionRedirects);
+    return res;
+  }, []);
+  const getContext = (from, to) => ` [Context: 
+- from: ${from}
+- to: ${to} ]`;
+  const formatMessage = (message, pathname, from, to) => `${pathname}: ${message} ${getContext(from, to)}`;
+  redirects.forEach((redirect) => {
+    const { from, to } = redirect;
+    if (!from || !to) {
+      throw new Error(formatMessage("One of the two parameters is missing", pathToRedirects, from, to));
+    }
+    if (from === to) {
+      throw new Error(formatMessage("Parameters must be different", pathToRedirects, from, to));
+    }
+  });
+}
+function argvValidator(argv) {
+  var _a, _b;
+  try {
+    const pathToConfig = argv.config ? String(argv.config) : (0, import_path2.join)(String(argv.input), YFM_CONFIG_FILENAME);
+    const content = (0, import_fs.readFileSync)((0, import_path2.resolve)(pathToConfig), "utf8");
+    Object.assign(argv, (0, import_js_yaml.load)(content) || {});
+  } catch (error) {
+    if (error.name === "YAMLException") {
+      import_log.default.error(`Error to parse ${YFM_CONFIG_FILENAME}: ${error.message}`);
+    }
+  }
+  let lintConfig = {};
+  try {
+    const pathToConfig = (0, import_path2.join)(String(argv.input), LINT_CONFIG_FILENAME);
+    const content = (0, import_fs.readFileSync)((0, import_path2.resolve)(pathToConfig), "utf8");
+    lintConfig = (0, import_js_yaml.load)(content) || {};
+  } catch (error) {
+    if (error.name === "YAMLException") {
+      import_log.default.error(`Error to parse ${LINT_CONFIG_FILENAME}: ${error.message}`);
+    }
+  } finally {
+    const preparedLintConfig = (0, import_merge.default)(lintConfig, {
+      "log-levels": {
+        MD033: argv.allowHTML ? "disabled" : "error"
+      }
+    });
+    Object.assign(argv, { lintConfig: preparedLintConfig });
+  }
+  try {
+    const pathToRedirects = (0, import_path2.join)(String(argv.input), REDIRECTS_FILENAME);
+    const redirectsContent = (0, import_fs.readFileSync)((0, import_path2.resolve)(pathToRedirects), "utf8");
+    const redirects = (0, import_js_yaml.load)(redirectsContent);
+    validateRedirects(redirects, pathToRedirects);
+  } catch (error) {
+    if (error.name === "YAMLException") {
+      import_log.default.error(`Error to parse ${REDIRECTS_FILENAME}: ${error.message}`);
+    }
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (argv.publish) {
+    for (const [field, validator] of Object.entries(validators)) {
+      const value = (_a = argv[field]) != null ? _a : validator.defaultValue;
+      if (!validator) {
+        continue;
+      }
+      const validateFn = (_b = validator.validateFn) != null ? _b : requiredValueValidator;
+      if (!validateFn(value)) {
+        throw new Error(validator.errorMessage);
+      }
+      argv[field] = value;
+    }
+  }
+  return true;
+}
+
+// src/cmd/build/index.ts
+var import_path27 = require("path");
+
+// src/services/tocs.ts
+var import_path13 = require("path");
+var import_fs4 = require("fs");
+var import_js_yaml4 = require("js-yaml");
+var import_shelljs2 = __toESM(require("shelljs"));
+var import_walk_sync = __toESM(require("walk-sync"));
+var import_liquid2 = __toESM(require("@doc-tools/transform/lib/liquid"));
+var import_log3 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_chalk2 = require("chalk");
+
+// src/services/metadata.ts
+var import_js_yaml2 = require("js-yaml");
+
+// src/utils/logger.ts
+var import_log2 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_chalk = require("chalk");
+function writeLog(msg, fatal = false) {
+  const { quiet } = argv_default.getConfig();
+  if (quiet && !fatal) {
+    return;
+  }
+  console.log(msg);
+}
+var logger = {
+  info: function(pathToFile, extraMessage) {
+    writeLog(`${(0, import_chalk.grey)("INFO")} ${extraMessage} ${pathToFile}`);
+  },
+  proc: function(pathToFile) {
+    writeLog(`${(0, import_chalk.blue)("PROC")} Processing file ${pathToFile}`);
+  },
+  copy: function(pathToFile) {
+    writeLog(`${(0, import_chalk.green)("COPY")} Copying file ${pathToFile}`);
+  },
+  upload: function(pathToFile) {
+    writeLog(`${(0, import_chalk.green)("UPLOAD")} Uploading file ${pathToFile}`);
+  },
+  warn: function(pathToFile, extraMessage) {
+    const message = `${(0, import_chalk.yellow)("WARNING")} file: ${pathToFile} error: ${extraMessage}`;
+    writeLog(message);
+    import_log2.default.warn(`file: ${pathToFile} ${extraMessage}`);
+  },
+  error: function(pathToFile, extraMessage) {
+    const message = `${(0, import_chalk.red)("ERROR")} file: ${pathToFile} error: ${extraMessage}`;
+    writeLog(message, true);
+    import_log2.default.error(`file: ${pathToFile} ${extraMessage}`);
+  }
+};
+
+// src/utils/markup.ts
+var import_process = require("process");
+
+// src/utils/singlePage.ts
+var import_node_html_parser = require("node-html-parser");
+var import_path3 = require("path");
+var import_utilsFS = require("@doc-tools/transform/lib/utilsFS");
+var import_url = __toESM(require("url"));
+var import_lodash = __toESM(require("lodash"));
+
+// src/utils/url.ts
+function isExternalHref(href) {
+  return href.startsWith("http") || href.startsWith("//");
+}
+
+// src/utils/singlePage.ts
+var HEADERS_SELECTOR = "h1, h2, h3, h4, h5, h6";
+function getNewNode(options) {
+  const { rawTagName, innerHTML, attrEntries } = options;
+  const nodeNew = (0, import_node_html_parser.parse)(`<html><${rawTagName}></${rawTagName}></html>`).querySelector(`${rawTagName}`);
+  if (!nodeNew) {
+    return null;
+  }
+  if (attrEntries) {
+    for (const [name4, value] of attrEntries) {
+      nodeNew.setAttribute(name4, value);
+    }
+  }
+  nodeNew.innerHTML = innerHTML;
+  return nodeNew;
+}
+function decreaseHeadingLevels(root) {
+  const headersSelector = "h1, h2, h3, h4, h5";
+  root.querySelectorAll(headersSelector).forEach((node) => {
+    const { rawTagName } = node;
+    const newHeadingLevel = Number(rawTagName.charAt(1)) + 1;
+    node.rawTagName = `h${newHeadingLevel}`;
+  });
+}
+function tryFixFirstPageHeader(root) {
+  const firstPageHeader = root.querySelector(HEADERS_SELECTOR);
+  if (!firstPageHeader || firstPageHeader.rawTagName === "h1") {
+    return;
+  }
+  firstPageHeader.rawTagName = "h1";
+}
+function replaceLinks(rootEl, options) {
+  const { root, path, tocDir } = options;
+  rootEl.querySelectorAll('a:not(.yfm-anchor):not([target="_blank"])').forEach((node) => {
+    const href = node.getAttribute("href") || "";
+    const resolvedPath = (0, import_path3.resolve)(root, path);
+    const linkFullPath = (0, import_utilsFS.resolveRelativePath)(resolvedPath, href);
+    const isLinkOutOfToc = !linkFullPath.startsWith(tocDir);
+    let preparedHref = href;
+    if (isLinkOutOfToc) {
+      preparedHref = (0, import_path3.relative)(tocDir, linkFullPath);
+    } else {
+      const { pathname, hash } = import_url.default.parse(href);
+      if (pathname) {
+        preparedHref = getSinglePageAnchorId({
+          root,
+          currentPath: resolvedPath,
+          pathname,
+          hash
+        });
+      } else if (hash) {
+        preparedHref = getSinglePageAnchorId({ root, currentPath: resolvedPath, hash });
+      }
+    }
+    node.setAttribute("href", preparedHref);
+  });
+}
+function replaceImages(rootEl, options) {
+  const { root, path, tocDir } = options;
+  rootEl.querySelectorAll("img").forEach((node) => {
+    const href = node.getAttribute("src") || "";
+    if (isExternalHref(href)) {
+      return;
+    }
+    const resolvedPath = (0, import_path3.resolve)(root, path);
+    const linkFullPath = (0, import_utilsFS.resolveRelativePath)(resolvedPath, href);
+    const preparedHref = (0, import_path3.relative)(tocDir, linkFullPath);
+    node.setAttribute("src", preparedHref);
+  });
+}
+function prepareAnchorAttr(name4, value, pageId) {
+  switch (name4) {
+    case "href":
+      return `#${pageId}_${value.slice(1)}`;
+    case "id":
+      return `${pageId}_${value}`;
+    default:
+      return value;
+  }
+}
+function prepareAnchorAttrs(node, pageId) {
+  for (const [name4, value] of Object.entries(node.attributes)) {
+    const preparedValue = prepareAnchorAttr(name4, value, pageId);
+    node.setAttribute(name4, preparedValue);
+  }
+}
+function addPagePrefixToAnchors(rootEl, options) {
+  const { root, path } = options;
+  const resolvedPath = (0, import_path3.resolve)(root, path);
+  const pageIdAnchor = getSinglePageAnchorId({ root, currentPath: resolvedPath });
+  const originalArticleHref = transformLinkToOriginalArticle({ root, currentPath: resolvedPath });
+  const pageId = pageIdAnchor.slice(1);
+  const anchorSelector = ".yfm-anchor";
+  rootEl.querySelectorAll(anchorSelector).forEach((node) => {
+    prepareAnchorAttrs(node, pageId);
+  });
+  const mainHeader = rootEl.querySelector("h1");
+  if (mainHeader) {
+    const anchor = (0, import_node_html_parser.parse)(`<a class="yfm-anchor" aria-hidden="true" href="${pageIdAnchor}" id="${pageId}"></a>`);
+    if (!anchor) {
+      return;
+    }
+    mainHeader.setAttribute("data-original-article", `${originalArticleHref}.html`);
+    mainHeader.appendChild(anchor);
+  }
+  rootEl.querySelectorAll(HEADERS_SELECTOR).forEach((node) => {
+    prepareAnchorAttrs(node, pageId);
+  });
+}
+function addMainTitle(rootEl, options) {
+  const { title } = options;
+  if (!title) {
+    return;
+  }
+  const mainTitle = getNewNode({ innerHTML: title, rawTagName: "h1" });
+  if (!mainTitle) {
+    return;
+  }
+  rootEl.insertAdjacentHTML("afterbegin", mainTitle.toString());
+}
+function getSinglePageAnchorId(args) {
+  const { root, currentPath, pathname, hash } = args;
+  let resultAnchor = currentPath;
+  if (pathname) {
+    resultAnchor = (0, import_utilsFS.resolveRelativePath)(currentPath, pathname);
+  }
+  resultAnchor = resultAnchor.replace(root, "").replace(/\.(md|ya?ml|html)$/i, "").replace(new RegExp(import_lodash.default.escapeRegExp(import_path3.sep), "gi"), "_");
+  if (hash) {
+    resultAnchor = resultAnchor + "_" + hash.slice(1);
+  }
+  return `#${resultAnchor}`;
+}
+function transformLinkToOriginalArticle(opts) {
+  const { root, currentPath } = opts;
+  return currentPath.replace(root, "").replace(/\.(md|ya?ml|html)$/i, "");
+}
+function preprocessPageHtmlForSinglePage(content, options) {
+  const root = (0, import_node_html_parser.parse)(content);
+  addMainTitle(root, options);
+  tryFixFirstPageHeader(root);
+  addPagePrefixToAnchors(root, options);
+  decreaseHeadingLevels(root);
+  replaceLinks(root, options);
+  replaceImages(root, options);
+  return root.toString();
+}
+
+// src/utils/markup.ts
+var import_client = require("@diplodoc/client");
+var import_client2 = __toESM(require_client());
+function generateStaticMarkup(props, pathToBundle) {
+  const { title: metaTitle, style, script } = props.data.meta || {};
+  const { title: tocTitle } = props.data.toc;
+  const { title: pageTitle } = props.data;
+  const title = getTitle({
+    metaTitle,
+    tocTitle,
+    pageTitle
+  });
+  const resources = getResources({ style, script });
+  const { staticContent } = argv_default.getConfig();
+  const html = staticContent ? (0, import_client.render)(props) : "";
+  return `
+        <!DOCTYPE html>
+        <html lang="${props.lang}">
+            <head>
+                <meta charset="utf-8">
+                ${getMetadata(props.data.meta)}
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>${title}</title>
+                <style type="text/css">
+                    body {
+                        height: 100vh;
+                    }
+                </style>
+                <link type="text/css" rel="stylesheet" href="${import_client2.default.bundle.css(pathToBundle)}" />
+                ${plugins_exports.getHeadContent()}
+                ${resources}
+            </head>
+            <body class="yc-root yc-root_theme_light">
+                <div id="root">${html}</div>
+                <script type="application/javascript">
+                   window.STATIC_CONTENT = ${staticContent}
+                   window.__DATA__ = ${JSON.stringify(props)};
+                </script>
+                <script type="application/javascript" src="${import_client2.default.bundle.js(pathToBundle)}"></script>
+            </body>
+        </html>
+    `;
+}
+function getTitle({ tocTitle, metaTitle, pageTitle }) {
+  const resultPageTitle = metaTitle || pageTitle;
+  if (!resultPageTitle && tocTitle) {
+    return tocTitle;
+  }
+  if (resultPageTitle && !tocTitle) {
+    return resultPageTitle;
+  }
+  return resultPageTitle && tocTitle ? `${resultPageTitle} | ${tocTitle}` : "";
+}
+function getMetadata(metadata) {
+  if (!metadata) {
+    return "";
+  }
+  const metaEntries = Object.entries(metadata).filter(([key]) => !Object.keys(ResourceType).includes(key));
+  return metaEntries.map(([name4, content]) => {
+    return `<meta name="${name4}" content="${content}">`;
+  }).join("\n");
+}
+function getResources({ style, script }) {
+  const resourcesTags = [];
+  if (style) {
+    style.forEach((el, id) => resourcesTags.push(
+      `<link rel="stylesheet" type="text/css" href="${el}" ${id === 0 && `id="${CUSTOM_STYLE}"`}>`
+    ));
+  }
+  if (script) {
+    script.forEach((el) => resourcesTags.push(
+      `<script src="${el}"></script>`
+    ));
+  }
+  return resourcesTags.join("\n");
+}
+var \u0441arriage = import_process.platform === "win32" /* WINDOWS */ ? "\r\n" : "\n";
+function joinSinglePageResults(singlePageResults2, root, tocDir) {
+  const delimeter = `${\u0441arriage}${\u0441arriage}<hr class="yfm-page__delimeter">${\u0441arriage}${\u0441arriage}`;
+  return singlePageResults2.filter(({ content }) => content).map(({ content, path, title }) => preprocessPageHtmlForSinglePage(content, { root, path, tocDir, title })).join(delimeter);
+}
+function replaceDoubleToSingleQuotes(str) {
+  return str.replace(/"/g, "'");
+}
+
+// src/utils/path.ts
+var import_path4 = require("path");
+function addSlashPrefix(path) {
+  const slashPrefix = path.startsWith(import_path4.sep) ? "" : import_path4.sep;
+  return `${slashPrefix}${path}`;
+}
+function convertBackSlashToSlash(path) {
+  if (process.platform === "win32" /* WINDOWS */) {
+    return path.replace(/\\/g, "/");
+  }
+  return path;
+}
+
+// src/utils/toc.ts
+var import_path5 = require("path");
+
+// src/services/utils.ts
+var import_evaluation = __toESM(require("@doc-tools/transform/lib/liquid/evaluation"));
+var import_liquid = __toESM(require("@doc-tools/transform/lib/liquid"));
+function filterFiles(items, itemsKey, vars, options) {
+  if (!Array.isArray(items)) {
+    return [];
+  }
+  const reducer = (results, item) => {
+    if (shouldProcessItem(item, vars, options)) {
+      const prop = item[itemsKey];
+      if (prop) {
+        const filteredProperty = filterFiles(prop, itemsKey, vars, options);
+        if (filteredProperty.length) {
+          results.push(__spreadProps(__spreadValues({}, item), {
+            [itemsKey]: filteredProperty
+          }));
+        }
+      } else {
+        results.push(item);
+      }
+    }
+    return results;
+  };
+  return items.reduce(reducer, []);
+}
+function filterTextItems(items, vars, options) {
+  if (!Array.isArray(items)) {
+    return items;
+  }
+  return items.reduce((result, item) => {
+    if (!isObject(item)) {
+      result.push(item);
+      return result;
+    }
+    const useItem = shouldProcessItem(item, vars, options);
+    if (useItem) {
+      if (Array.isArray(item.text)) {
+        result.push(...item.text);
+      } else {
+        result.push(item.text);
+      }
+    }
+    return result;
+  }, []);
+}
+function firstFilterTextItems(items, vars, options) {
+  const filteredItems = filterTextItems(items, vars, options);
+  if (!Array.isArray(filteredItems)) {
+    return filteredItems || "";
+  }
+  return filteredItems[0] || "";
+}
+function shouldProcessItem(item, vars, options) {
+  const { resolveConditions, removeHiddenTocItems } = options || {};
+  let useItem = true;
+  if (resolveConditions) {
+    const { when } = item;
+    useItem = when === true || when === void 0 || typeof when === "string" && (0, import_evaluation.default)(when, vars);
+    delete item.when;
+  }
+  if (useItem && removeHiddenTocItems) {
+    useItem = !item.hidden;
+    delete item.hidden;
+  }
+  return useItem;
+}
+function liquidFields(fields, vars, path) {
+  if (typeof fields === "string") {
+    return liquidField(fields, vars, path);
+  }
+  if (!Array.isArray(fields)) {
+    return fields;
+  }
+  return fields.map((item) => {
+    if (typeof item === "string") {
+      return liquidField(item, vars, path);
+    }
+    return item;
+  });
+}
+function liquidField(input, vars, path) {
+  const { applyPresets, resolveConditions } = argv_default.getConfig();
+  if (!applyPresets && !resolveConditions) {
+    return input;
+  }
+  return (0, import_liquid.default)(input, vars, path, {
+    substitutions: applyPresets,
+    conditions: resolveConditions,
+    keepNotVar: true,
+    withSourceMap: false
+  });
+}
+function isObject(o) {
+  return typeof o === "object" && o !== null;
+}
+
+// src/utils/toc.ts
+function transformToc(toc, pathToFileDirectory) {
+  if (!toc) {
+    return null;
+  }
+  const localToc = JSON.parse(JSON.stringify(toc));
+  if (localToc.items) {
+    localToc.items = filterFiles(localToc.items, "items", {}, {
+      removeHiddenTocItems: true
+    });
+  }
+  const baseTocPath = localToc.base || "";
+  const navigationItemQueue = [localToc];
+  while (navigationItemQueue.length) {
+    const navigationItem = navigationItemQueue.shift();
+    if (!navigationItem) {
+      continue;
+    }
+    const { items, href } = navigationItem;
+    if (items) {
+      navigationItemQueue.push(...navigationItem.items);
+    }
+    if (href && !isExternalHref(href)) {
+      const pathToIndexDirectory = (0, import_path5.relative)(pathToFileDirectory, baseTocPath);
+      const fileExtension = (0, import_path5.extname)(href);
+      const filename = (0, import_path5.basename)(href, fileExtension);
+      const transformedFilename = (0, import_path5.format)({
+        name: filename,
+        ext: ".html"
+      });
+      navigationItem.href = (0, import_path5.join)(pathToIndexDirectory, (0, import_path5.dirname)(href), transformedFilename);
+    }
+  }
+  return localToc;
+}
+function transformTocForSinglePage(toc, options) {
+  const { root, currentPath } = options;
+  if (!toc) {
+    return null;
+  }
+  const localToc = JSON.parse(JSON.stringify(toc));
+  if (localToc.items) {
+    localToc.items = filterFiles(localToc.items, "items", {}, {
+      removeHiddenTocItems: true
+    });
+  }
+  function processItems(items) {
+    items.forEach((item) => {
+      if (item.items) {
+        processItems(item.items);
+      }
+      if (item.href && !isExternalHref(item.href)) {
+        item.href = getSinglePageAnchorId({ root, currentPath, pathname: item.href });
+      }
+    });
+  }
+  processItems(localToc.items);
+  localToc.singlePage = true;
+  return localToc;
+}
+
+// src/utils/presets.ts
+var import_path6 = require("path");
+function getVarsPerFile(filePath) {
+  const { vars: argVars } = argv_default.getConfig();
+  return __spreadValues(__spreadValues({}, preset_default.get((0, import_path6.dirname)(filePath))), argVars);
+}
+function getVarsPerRelativeFile(filePath) {
+  const { input } = argv_default.getConfig();
+  const root = (0, import_path6.resolve)(input);
+  const relativeFilePath = (0, import_path6.relative)(root, filePath);
+  return getVarsPerFile(relativeFilePath);
+}
+
+// src/utils/glob.ts
+var import_glob = __toESM(require("glob"));
+var glob = (pattern, options) => __async(void 0, null, function* () {
+  return new Promise((res, rej) => {
+    const state = (0, import_glob.default)(
+      pattern,
+      options,
+      (err) => err ? rej(err) : res({ state })
+    );
+  });
+});
+
+// src/utils/file.ts
+var import_path7 = require("path");
+var import_shelljs = __toESM(require("shelljs"));
+var import_fs2 = require("fs");
+function copyFiles(inputFolderPath, outputFolderPath, files) {
+  for (const pathToAsset of files) {
+    const outputDir = (0, import_path7.resolve)(outputFolderPath, (0, import_path7.dirname)(pathToAsset));
+    const from = (0, import_path7.resolve)(inputFolderPath, pathToAsset);
+    const to = (0, import_path7.resolve)(outputFolderPath, pathToAsset);
+    import_shelljs.default.mkdir("-p", outputDir);
+    (0, import_fs2.copyFileSync)(from, to);
+    logger.copy(pathToAsset);
+  }
+}
+
+// src/services/authors.ts
+function updateAuthorMetadataStringByAuthorLogin(authorLogin, vcsConnector) {
+  return __async(this, null, function* () {
+    if (!vcsConnector) {
+      return "";
+    }
+    const user = yield getAuthorDetails(vcsConnector, authorLogin);
+    if (user) {
+      return user;
+    }
+    return "";
+  });
+}
+function updateAuthorMetadataStringByFilePath(filePath, vcsConnector) {
+  return __async(this, null, function* () {
+    if (!vcsConnector) {
+      return "";
+    }
+    const user = vcsConnector.getExternalAuthorByPath(filePath);
+    if (user) {
+      const author = replaceDoubleToSingleQuotes(JSON.stringify(user));
+      return author;
+    }
+    return "";
+  });
+}
+function getAuthorDetails(vcsConnector, author) {
+  return __async(this, null, function* () {
+    if (typeof author === "object") {
+      return replaceDoubleToSingleQuotes(JSON.stringify(author));
+    }
+    try {
+      JSON.parse(author);
+      return replaceDoubleToSingleQuotes(author);
+    } catch (e) {
+      const user = yield vcsConnector.getUserByLogin(author);
+      if (user) {
+        return replaceDoubleToSingleQuotes(JSON.stringify(user));
+      }
+      return null;
+    }
+  });
+}
+
+// src/services/contributors.ts
+var import_promises = require("fs/promises");
+var import_path8 = require("path");
+function getFileContributorsMetadata(fileData, vcsConnector) {
+  return __async(this, null, function* () {
+    const contributors = yield getFileContributorsString(fileData, vcsConnector);
+    return `contributors: ${contributors}`;
+  });
+}
+function getFileContributorsString(fileData, vcsConnector) {
+  return __async(this, null, function* () {
+    const { tmpInputFilePath, inputFolderPathLength } = fileData;
+    const relativeFilePath = tmpInputFilePath.substring(inputFolderPathLength);
+    const fileContributors = yield vcsConnector.getContributorsByPath(relativeFilePath);
+    let nestedContributors = {};
+    if (!fileContributors.hasIncludes) {
+      nestedContributors = yield getContributorsForNestedFiles(fileData, vcsConnector);
+      vcsConnector.addNestedContributorsForPath(relativeFilePath, nestedContributors);
+    }
+    const fileContributorsWithContributorsIncludedFiles = __spreadValues(__spreadValues({}, fileContributors.contributors), nestedContributors);
+    const contributorsArray = Object.entries(fileContributorsWithContributorsIncludedFiles).map(([, contributor]) => contributor);
+    return replaceDoubleToSingleQuotes(JSON.stringify(contributorsArray));
+  });
+}
+function getContributorsForNestedFiles(fileData, vcsConnector) {
+  return __async(this, null, function* () {
+    const { fileContent, inputFolderPathLength } = fileData;
+    const includeContents = fileContent.match(REGEXP_INCLUDE_CONTENTS);
+    if (!includeContents || includeContents.length === 0) {
+      return {};
+    }
+    const includesContributors = [];
+    const relativeIncludeFilePaths = getRelativeIncludeFilePaths(fileData, includeContents);
+    for (const relativeIncludeFilePath of relativeIncludeFilePaths.values()) {
+      const relativeFilePath = relativeIncludeFilePath.substring(inputFolderPathLength);
+      const includeContributors = yield vcsConnector.getContributorsByPath(relativeFilePath);
+      let nestedContributors = {};
+      if (!includeContributors.hasIncludes) {
+        let contentIncludeFile;
+        try {
+          contentIncludeFile = yield (0, import_promises.readFile)(relativeIncludeFilePath, "utf8");
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            continue;
+          }
+          throw err;
+        }
+        const newFileData = __spreadProps(__spreadValues({}, fileData), {
+          fileContent: contentIncludeFile,
+          tmpInputFilePath: relativeIncludeFilePath
+        });
+        nestedContributors = yield getContributorsForNestedFiles(newFileData, vcsConnector);
+        vcsConnector.addNestedContributorsForPath(relativeFilePath, nestedContributors);
+      }
+      includesContributors.push(includeContributors.contributors);
+      includesContributors.push(nestedContributors);
+    }
+    return Object.assign({}, ...includesContributors);
+  });
+}
+function getRelativeIncludeFilePaths(fileData, includeContents) {
+  const { tmpInputFilePath } = fileData;
+  const relativeIncludeFilePaths = /* @__PURE__ */ new Set();
+  includeContents.forEach((includeContent) => {
+    const relativeIncludeFilePath = includeContent.match(REGEXP_INCLUDE_FILE_PATH);
+    if (relativeIncludeFilePath && relativeIncludeFilePath.length !== 0) {
+      const relativeIncludeFilePathWithoutHash = relativeIncludeFilePath[0].split("#");
+      const includeFilePath = (0, import_path8.join)((0, import_path8.dirname)(tmpInputFilePath), relativeIncludeFilePathWithoutHash[0]);
+      relativeIncludeFilePaths.add(includeFilePath);
+    }
+  });
+  return relativeIncludeFilePaths;
+}
+
+// src/services/metadata.ts
+var import_path9 = require("path");
+function getContentWithUpdatedMetadata(fileContent, options, systemVars) {
+  return __async(this, null, function* () {
+    var _a;
+    let result;
+    result = getContentWithUpdatedStaticMetadata({
+      fileContent,
+      sourcePath: (_a = options == null ? void 0 : options.fileData) == null ? void 0 : _a.sourcePath,
+      addSystemMeta: options == null ? void 0 : options.addSystemMeta,
+      addSourcePath: options == null ? void 0 : options.addSourcePath,
+      resources: options == null ? void 0 : options.resources,
+      systemVars
+    });
+    result = yield getContentWithUpdatedDynamicMetadata(result, options);
+    return result;
+  });
+}
+function getContentWithUpdatedStaticMetadata({
+  fileContent,
+  sourcePath,
+  addSystemMeta,
+  addSourcePath,
+  resources,
+  systemVars
+}) {
+  const newMetadatas = [];
+  if ((!addSystemMeta || !systemVars) && !addSourcePath && !resources) {
+    return fileContent;
+  }
+  const matches = matchMetadata(fileContent);
+  if (addSystemMeta && systemVars && isObject(systemVars)) {
+    newMetadatas.push(getSystemVarsMetadataString(systemVars));
+  }
+  if (resources) {
+    newMetadatas.push((0, import_js_yaml2.dump)(resources));
+  }
+  if (addSourcePath && sourcePath) {
+    const sourcePathMetadataString = `sourcePath: ${sourcePath}`;
+    newMetadatas.push(sourcePathMetadataString);
+  }
+  if (matches && matches.length > 0) {
+    const [, fileMetadata, , fileMainContent] = matches;
+    return `${getUpdatedMetadataString(newMetadatas, fileMetadata)}${fileMainContent}`;
+  }
+  return `${getUpdatedMetadataString(newMetadatas)}${fileContent}`;
+}
+function getContentWithUpdatedDynamicMetadata(fileContent, options) {
+  return __async(this, null, function* () {
+    if (!options || !(options == null ? void 0 : options.isContributorsEnabled)) {
+      return fileContent;
+    }
+    let fileMetadata, fileMainContent;
+    const matches = matchMetadata(fileContent);
+    if (matches && matches.length > 0) {
+      const [, matchedFileMetadata, , matchedFileMainContent] = matches;
+      fileMetadata = matchedFileMetadata;
+      fileMainContent = matchedFileMainContent;
+    }
+    const newMetadatas = [];
+    const { isContributorsEnabled } = options;
+    if (isContributorsEnabled) {
+      const contributorsMetaData = yield getContributorsMetadataString(options, fileContent);
+      if (contributorsMetaData) {
+        newMetadatas.push(contributorsMetaData);
+      }
+      let authorMetadata = "";
+      if (fileMetadata) {
+        const matchAuthor = fileMetadata.match(REGEXP_AUTHOR);
+        if (matchAuthor) {
+          const matchedAuthor = matchAuthor[0];
+          authorMetadata = yield updateAuthorMetadataStringByAuthorLogin(matchedAuthor, options.vcsConnector);
+        }
+      }
+      if (!authorMetadata) {
+        const { fileData: { tmpInputFilePath, inputFolderPathLength } } = options;
+        const relativeFilePath = tmpInputFilePath.substring(inputFolderPathLength);
+        authorMetadata = yield updateAuthorMetadataStringByFilePath(relativeFilePath, options.vcsConnector);
+      }
+      if (authorMetadata) {
+        newMetadatas.push(`author: ${authorMetadata}`);
+      }
+    }
+    if (fileMetadata && fileMainContent) {
+      let updatedFileMetadata = fileMetadata;
+      const matchAuthor = fileMetadata.match(REGEXP_AUTHOR);
+      const isNewMetadataIncludesAuthor = newMetadatas.some((item) => /^author: /.test(item));
+      if (matchAuthor && isNewMetadataIncludesAuthor) {
+        updatedFileMetadata = updatedFileMetadata.replace(`author: ${matchAuthor[0]}`, "");
+      }
+      return `${getUpdatedMetadataString(newMetadatas, updatedFileMetadata)}${fileMainContent}`;
+    }
+    return `${getUpdatedMetadataString(newMetadatas)}${fileContent}`;
+  });
+}
+function matchMetadata(fileContent) {
+  if (!fileContent.startsWith("---")) {
+    return null;
+  }
+  const regexpMetadata = "(?<=-{3}\\r?\\n)((.*\\r?\\n)*?)(?=-{3}\\r?\\n)";
+  const regexpFileContent = "-{3}((.*[\r?\n]*)*)";
+  const regexpParseFileContent = new RegExp(`${regexpMetadata}${regexpFileContent}`, "gm");
+  return regexpParseFileContent.exec(fileContent);
+}
+function getContributorsMetadataString(options, fileContent) {
+  return __async(this, null, function* () {
+    const { isContributorsEnabled, vcsConnector, fileData } = options;
+    if (isContributorsEnabled && vcsConnector) {
+      const updatedFileData = __spreadProps(__spreadValues({}, fileData), {
+        fileContent
+      });
+      return getFileContributorsMetadata(updatedFileData, vcsConnector);
+    }
+    return void 0;
+  });
+}
+function getUpdatedMetadataString(newMetadatas, defaultMetadata = "") {
+  const newMetadata = newMetadatas.join(\u0441arriage) + (newMetadatas.length ? \u0441arriage : "");
+  const preparedDefaultMetadata = defaultMetadata.trimRight();
+  const defaultMetadata\u0421arriage = preparedDefaultMetadata ? \u0441arriage : "";
+  const updatedMetadata = `${preparedDefaultMetadata}${defaultMetadata\u0421arriage}${newMetadata}`;
+  return `${metadataBorder}${\u0441arriage}${updatedMetadata}${metadataBorder}${defaultMetadata.length ? "" : \u0441arriage}`;
+}
+function getUpdatedMetadata(options, fileContent, meta2) {
+  return __async(this, null, function* () {
+    const { vcsConnector } = options;
+    const newMetadata = {
+      contributors: yield getContributorsMetadata(options, fileContent)
+    };
+    if (!meta2) {
+      return newMetadata;
+    }
+    const updatedAuthor = yield getAuthorMetadata(meta2, vcsConnector);
+    return __spreadProps(__spreadValues(__spreadValues({}, meta2), newMetadata), {
+      author: updatedAuthor
+    });
+  });
+}
+function getContributorsMetadata(options, fileContent) {
+  return __async(this, null, function* () {
+    const { isContributorsEnabled, vcsConnector, fileData } = options;
+    if (isContributorsEnabled && vcsConnector) {
+      const updatedFileData = __spreadProps(__spreadValues({}, fileData), {
+        fileContent
+      });
+      return getFileContributorsString(updatedFileData, vcsConnector);
+    }
+    return JSON.stringify([]);
+  });
+}
+function getAuthorMetadata(meta2, vcsConnector) {
+  return __async(this, null, function* () {
+    if (meta2.author && vcsConnector) {
+      const updatedAuthor = yield getAuthorDetails(vcsConnector, meta2.author);
+      return updatedAuthor;
+    }
+    return null;
+  });
+}
+function getSystemVarsMetadataString(systemVars) {
+  return `__system: ${JSON.stringify(systemVars)}`;
+}
+function getAssetsPublicPath(filePath) {
+  const { input } = argv_default.getConfig();
+  const path = (0, import_path9.resolve)(input, filePath);
+  return (0, import_path9.relative)((0, import_path9.dirname)(path), (0, import_path9.resolve)(input));
+}
+
+// src/services/includers/index.ts
+var includers_exports = {};
+__export(includers_exports, {
+  IncludersError: () => IncludersError,
+  applyIncluders: () => applyIncluders,
+  init: () => init
+});
+var import_path12 = require("path");
+var import_lodash3 = require("lodash");
+
+// src/services/includers/batteries/generic.ts
+var generic_exports = {};
+__export(generic_exports, {
+  default: () => generic_default,
+  includerFunction: () => includerFunction,
+  name: () => name
+});
+var import_promises2 = require("fs/promises");
+var import_path10 = require("path");
+var import_lodash2 = require("lodash");
+var import_js_yaml3 = require("js-yaml");
+var GenericIncluderError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.name = "GenericIncluderError";
+    this.path = path;
+  }
+};
+var name = "generic";
+var MD_GLOB = "**/*.md";
+function includerFunction(params) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const { readBasePath, writeBasePath, tocPath, item, passedParams: { input, leadingPage }, index } = params;
+    if (!(input == null ? void 0 : input.length) || !((_a = item.include) == null ? void 0 : _a.path)) {
+      throw new GenericIncluderError("provide includer with input parameter", tocPath);
+    }
+    try {
+      const leadingPageName = (_b = leadingPage == null ? void 0 : leadingPage.name) != null ? _b : "Overview";
+      const tocDirPath = (0, import_path10.dirname)(tocPath);
+      const contentPath = index === 0 ? (0, import_path10.join)(writeBasePath, tocDirPath, input) : (0, import_path10.join)(readBasePath, tocDirPath, input);
+      let cache = {};
+      let found = [];
+      ({ state: { found, cache } } = yield glob(MD_GLOB, {
+        cwd: contentPath,
+        nosort: true,
+        nocase: true,
+        cache
+      }));
+      const writePath = (0, import_path10.join)(writeBasePath, tocDirPath, item.include.path);
+      yield (0, import_promises2.mkdir)(writePath, { recursive: true });
+      for (const filePath of found) {
+        const file = yield (0, import_promises2.readFile)((0, import_path10.join)(contentPath, filePath));
+        yield (0, import_promises2.mkdir)((0, import_path10.dirname)((0, import_path10.join)(writePath, filePath)), { recursive: true });
+        yield (0, import_promises2.writeFile)((0, import_path10.join)(writePath, filePath), file);
+      }
+      const graph = createGraphFromPaths(found);
+      const toc = createToc(leadingPageName, item.include.path)(graph, []);
+      yield (0, import_promises2.writeFile)((0, import_path10.join)(writePath, "toc.yaml"), (0, import_js_yaml3.dump)(toc));
+    } catch (err) {
+      throw new GenericIncluderError(err.toString(), tocPath);
+    }
+  });
+}
+function createGraphFromPaths(paths) {
+  const graph = {};
+  for (const path of paths) {
+    const chunks = path.split("/").filter(Boolean);
+    if (chunks.length < 2) {
+      if (chunks.length === 1) {
+        graph.files = chunks;
+      }
+      continue;
+    }
+    const file = chunks.pop();
+    (0, import_lodash2.updateWith)(graph, chunks, (old) => {
+      return old ? { files: [...old.files, file] } : { files: [file] };
+    }, Object);
+  }
+  return graph;
+}
+function createToc(leadingPageName, tocName) {
+  return function createTocRec(graph, cursor) {
+    var _a, _b;
+    const handler6 = (file) => ({
+      name: (0, import_path10.parse)(file).name === "index" ? leadingPageName : file,
+      href: (0, import_path10.join)(...cursor, file)
+    });
+    const recurse = (key) => createTocRec(graph[key], [...cursor, key]);
+    const current = {
+      name: (_a = cursor[cursor.length - 1]) != null ? _a : tocName,
+      items: [
+        ...((_b = graph.files) != null ? _b : []).map(handler6),
+        ...Object.keys(graph).filter((key) => key !== "files").map(recurse)
+      ]
+    };
+    return current;
+  };
+}
+var generic_default = { name, includerFunction };
+
+// src/services/includers/batteries/sourcedocs.ts
+var sourcedocs_exports = {};
+__export(sourcedocs_exports, {
+  default: () => sourcedocs_default,
+  includerFunction: () => includerFunction2,
+  name: () => name2
+});
+var name2 = "sourcedocs";
+var usage = `include:
+  path: <path-where-to-include>
+  includers:
+    - name: generic
+      input: <path-to-directory-with-markdown>
+      leadingPage:
+        name: <leading-page-name>
+`;
+function includerFunction2(params) {
+  return __async(this, null, function* () {
+    logger.warn(params.tocPath, `sourcedocs inlcuder is getting depricated in favor of generic includer
+${usage}`);
+    yield generic_default.includerFunction(params);
+  });
+}
+var sourcedocs_default = { name: name2, includerFunction: includerFunction2 };
+
+// src/services/includers/batteries/unarchive.ts
+var unarchive_exports = {};
+__export(unarchive_exports, {
+  default: () => unarchive_default,
+  includerFunction: () => includerFunction3,
+  name: () => name3
+});
+var import_fs3 = require("fs");
+var import_path11 = require("path");
+var import_tar_stream = require("tar-stream");
+var name3 = "unarchive";
+var UnarchiveIncluderError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.name = "UnarchiveIncluderError";
+    this.path = path;
+  }
+};
+function pipeline(readPath, writeBasePath) {
+  return new Promise((res, rej) => {
+    const reader3 = (0, import_fs3.createReadStream)(readPath);
+    reader3.on("error", (err) => {
+      rej(err);
+    });
+    const extractor2 = (0, import_tar_stream.extract)();
+    extractor2.on("error", (err) => {
+      rej(err);
+    });
+    (0, import_fs3.mkdirSync)(writeBasePath, { recursive: true });
+    extractor2.on("entry", (header, stream, next) => {
+      const { type, name: name4 } = header;
+      const writePath = (0, import_path11.join)(writeBasePath, name4);
+      const writeDirPath = type === "directory" ? writePath : (0, import_path11.dirname)(writePath);
+      (0, import_fs3.mkdirSync)(writeDirPath, { recursive: true });
+      if (type !== "directory") {
+        const writer3 = (0, import_fs3.createWriteStream)(writePath, { flags: "w" });
+        writer3.on("error", (err) => {
+          rej(err);
+        });
+        stream.pipe(writer3);
+      }
+      stream.on("end", () => {
+        next();
+      });
+      stream.resume();
+    });
+    reader3.pipe(extractor2).on("finish", () => {
+      res();
+    });
+  });
+}
+function includerFunction3(params) {
+  return __async(this, null, function* () {
+    const { readBasePath, writeBasePath, tocPath, passedParams: { input, output }, index } = params;
+    if (!(input == null ? void 0 : input.length) || !(output == null ? void 0 : output.length)) {
+      throw new UnarchiveIncluderError("provide includer with input parameter", tocPath);
+    }
+    const contentPath = index === 0 ? (0, import_path11.join)(writeBasePath, input) : (0, import_path11.join)(readBasePath, input);
+    const writePath = (0, import_path11.join)(writeBasePath, output);
+    try {
+      yield pipeline(contentPath, writePath);
+    } catch (err) {
+      throw new UnarchiveIncluderError(err.toString(), tocPath);
+    }
+  });
+}
+var unarchive_default = { name: name3, includerFunction: includerFunction3 };
+
+// src/services/includers/index.ts
+var includersUsage = `include:
+  path: <path-where-to-include>
+  includers:
+    - name: <includer-name-0>
+      <includer-parameter>: <value-for-includer-parameter>
+    - name: <includer-name-1>
+      <includer-parameter>: <value-for-includer-parameter>
+`;
+var includersMap;
+var IncludersError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.name = "IncludersError";
+    this.path = path;
+  }
+};
+function init(custom = []) {
+  if (includersMap) {
+    return;
+  }
+  includersMap = { generic: generic_exports, sourcedocs: sourcedocs_exports, unarchive: unarchive_exports };
+  for (const includer of custom) {
+    includersMap[includer.name] = includer;
+  }
+}
+function applyIncluders(path, item, vars) {
+  return __async(this, null, function* () {
+    var _a;
+    if (!((_a = item.include) == null ? void 0 : _a.includers)) {
+      return;
+    }
+    if (!includeValid(item.include)) {
+      throw new IncludersError("include doesn't comply with includers standard", path);
+    }
+    item.include.mode = "link" /* LINK */;
+    const { status, message } = includersValid(item.include.includers);
+    if (!status) {
+      throw new IncludersError(message != null ? message : "", path);
+    }
+    let index = 0;
+    for (const _b of item.include.includers) {
+      const _c = _b, { name: name4 } = _c, rest = __objRest(_c, ["name"]);
+      const includer = getIncluder(name4);
+      const passedParams = __spreadValues({}, rest);
+      yield applyIncluder({ path, item, includer, passedParams, index, vars });
+    }
+    item.include.path = (0, import_path12.join)(item.include.path, "toc.yaml");
+    index++;
+  });
+}
+function includeValid(include) {
+  var _a;
+  return (include.mode === "link" /* LINK */ || !include.mode) && ((_a = include.path) == null ? void 0 : _a.length);
+}
+function includersValid(includers) {
+  for (const includer of includers) {
+    const { status, message } = includerValid(includer);
+    if (!status) {
+      return { status, message };
+    }
+  }
+  return { status: true };
+}
+function includerValid(includer) {
+  if ((0, import_lodash3.isObject)(includer)) {
+    if (typeof includer.name !== "string") {
+      return {
+        status: false,
+        message: "use string in the includer.name to specify includers name"
+      };
+    }
+    if (includerExists(includer)) {
+      return { status: true };
+    }
+    return { status: false, message: `includer ${includer.name} not implemented` };
+  }
+  return {
+    status: false,
+    message: `use appropriate includers format:
+${includersUsage}`
+  };
+}
+function getIncluder(includerName) {
+  return includersMap[includerName];
+}
+function includerExists(includer) {
+  return includersMap[includer.name];
+}
+function applyIncluder(args) {
+  return __async(this, null, function* () {
+    const { rootInput: readBasePath, input: writeBasePath } = argv_default.getConfig();
+    const { path, item, includer, passedParams, index, vars } = args;
+    const params = {
+      tocPath: path,
+      passedParams,
+      index,
+      item,
+      readBasePath,
+      writeBasePath,
+      vars
+    };
+    return yield includer.includerFunction(params);
+  });
+}
+
+// src/services/tocs.ts
+var storage = /* @__PURE__ */ new Map();
+var navigationPaths = [];
+var includedTocPaths = /* @__PURE__ */ new Set();
+function add(path) {
+  return __async(this, null, function* () {
+    const {
+      input: inputFolderPath,
+      output: outputFolderPath,
+      outputFormat,
+      ignoreStage,
+      vars
+    } = argv_default.getConfig();
+    const pathToDir = (0, import_path13.dirname)(path);
+    const content = (0, import_fs4.readFileSync)((0, import_path13.resolve)(inputFolderPath, path), "utf8");
+    const parsedToc = (0, import_js_yaml4.load)(content);
+    if (parsedToc.stage === ignoreStage) {
+      return;
+    }
+    const combinedVars = __spreadValues(__spreadValues({}, preset_default.get(pathToDir)), vars);
+    if (parsedToc.title) {
+      parsedToc.title = firstFilterTextItems(
+        parsedToc.title,
+        combinedVars,
+        { resolveConditions: true }
+      );
+    }
+    if (typeof parsedToc.title === "string") {
+      parsedToc.title = liquidField(parsedToc.title, combinedVars, path);
+    }
+    parsedToc.items = yield processTocItems(
+      path,
+      parsedToc.items,
+      (0, import_path13.join)(inputFolderPath, pathToDir),
+      (0, import_path13.resolve)(inputFolderPath),
+      combinedVars
+    );
+    storage.set(path, parsedToc);
+    parsedToc.base = pathToDir;
+    if (outputFormat === "md") {
+      const outputPath = (0, import_path13.resolve)(outputFolderPath, path);
+      const outputToc = (0, import_js_yaml4.dump)(parsedToc);
+      import_shelljs2.default.mkdir("-p", (0, import_path13.dirname)(outputPath));
+      (0, import_fs4.writeFileSync)(outputPath, outputToc);
+    }
+    prepareNavigationPaths(parsedToc, pathToDir);
+  });
+}
+function processTocItems(path, items, tocDir, sourcesDir, vars) {
+  return __async(this, null, function* () {
+    const {
+      resolveConditions,
+      removeHiddenTocItems
+    } = argv_default.getConfig();
+    let preparedItems = items;
+    if (resolveConditions || removeHiddenTocItems) {
+      try {
+        preparedItems = filterFiles(items, "items", vars, {
+          resolveConditions,
+          removeHiddenTocItems
+        });
+      } catch (error) {
+        import_log3.default.error(`Error while filtering toc file: ${path}. Error message: ${error}`);
+      }
+    }
+    return _replaceIncludes(path, preparedItems, tocDir, sourcesDir, vars);
+  });
+}
+function getForPath(path) {
+  return storage.get(path);
+}
+function getNavigationPaths() {
+  return [...navigationPaths];
+}
+function getIncludedTocPaths() {
+  return [...includedTocPaths];
+}
+function prepareNavigationPaths(parsedToc, dirPath) {
+  function processItems(items, pathToDir) {
+    items.forEach((item) => {
+      if (!parsedToc.singlePage && item.items) {
+        const preparedSubItems = item.items.map((yfmToc, index) => {
+          yfmToc.id = `${yfmToc.name}-${index}-${Math.random()}`;
+          return yfmToc;
+        });
+        processItems(preparedSubItems, pathToDir);
+      }
+      if (item.href && !isExternalHref(item.href)) {
+        const href = (0, import_path13.join)(pathToDir, item.href);
+        storage.set(href, parsedToc);
+        const navigationPath = _normalizeHref(href);
+        navigationPaths.push(navigationPath);
+      }
+    });
+  }
+  processItems([parsedToc], dirPath);
+}
+function _normalizeHref(href) {
+  const preparedHref = (0, import_path13.normalize)(href);
+  if (preparedHref.endsWith(".md") || preparedHref.endsWith(".yaml")) {
+    return preparedHref;
+  }
+  if (preparedHref.endsWith(import_path13.sep)) {
+    return `${preparedHref}index.yaml`;
+  }
+  return `${preparedHref}.md`;
+}
+function _copyTocDir(tocPath, destDir) {
+  const { input: inputFolderPath } = argv_default.getConfig();
+  const { dir: tocDir } = (0, import_path13.parse)(tocPath);
+  const files = (0, import_walk_sync.default)(tocDir, {
+    globs: ["**/*.*"],
+    ignore: ["**/toc.yaml"],
+    directories: false
+  });
+  files.forEach((relPath) => {
+    const from = (0, import_path13.resolve)(tocDir, relPath);
+    const to = (0, import_path13.resolve)(destDir, relPath);
+    const fileExtension = (0, import_path13.extname)(relPath);
+    const isMdFile = fileExtension === ".md";
+    import_shelljs2.default.mkdir("-p", (0, import_path13.parse)(to).dir);
+    if (isMdFile) {
+      const fileContent = (0, import_fs4.readFileSync)(from, "utf8");
+      const sourcePath = (0, import_path13.relative)(inputFolderPath, from);
+      const updatedFileContent = getContentWithUpdatedStaticMetadata({
+        fileContent,
+        sourcePath,
+        addSourcePath: true
+      });
+      (0, import_fs4.writeFileSync)(to, updatedFileContent);
+    } else {
+      (0, import_fs4.copyFileSync)(from, to);
+    }
+  });
+}
+function _replaceIncludesHrefs(items, includeTocDir, tocDir) {
+  return items.reduce((acc, tocItem) => {
+    if (tocItem.href) {
+      tocItem.href = (0, import_path13.relative)(tocDir, (0, import_path13.resolve)(includeTocDir, tocItem.href));
+    }
+    if (tocItem.items) {
+      tocItem.items = _replaceIncludesHrefs(tocItem.items, includeTocDir, tocDir);
+    }
+    if (tocItem.include) {
+      const { path } = tocItem.include;
+      tocItem.include.path = (0, import_path13.relative)(tocDir, (0, import_path13.resolve)(includeTocDir, path));
+    }
+    return acc.concat(tocItem);
+  }, []);
+}
+function _liquidSubstitutions(input, vars, path) {
+  const { outputFormat, applyPresets } = argv_default.getConfig();
+  if (outputFormat === "md" && !applyPresets) {
+    return input;
+  }
+  return (0, import_liquid2.default)(input, vars, path, {
+    conditions: false,
+    substitutions: true
+  });
+}
+function addIncludeTocPath(includeTocPath) {
+  includedTocPaths.add(includeTocPath);
+}
+function _replaceIncludes(path, items, tocDir, sourcesDir, vars) {
+  return __async(this, null, function* () {
+    const result = [];
+    for (const item of items) {
+      let includedInlineItems = null;
+      if (item.name) {
+        const tocPath = (0, import_path13.join)(tocDir, "toc.yaml");
+        item.name = _liquidSubstitutions(item.name, vars, tocPath);
+      }
+      try {
+        yield applyIncluders(path, item, vars);
+      } catch (err) {
+        if (err instanceof Error || err instanceof IncludersError) {
+          const message = err.toString();
+          const file = err instanceof IncludersError ? err.path : path;
+          logger.error(file, message);
+        }
+      }
+      if (item.include) {
+        const { mode = "root_merge" /* ROOT_MERGE */ } = item.include;
+        const includeTocPath = mode === "root_merge" /* ROOT_MERGE */ ? (0, import_path13.resolve)(sourcesDir, item.include.path) : (0, import_path13.resolve)(tocDir, item.include.path);
+        const includeTocDir = (0, import_path13.dirname)(includeTocPath);
+        try {
+          const includeToc = (0, import_js_yaml4.load)((0, import_fs4.readFileSync)(includeTocPath, "utf8"));
+          if (includeToc.stage === "tech-preview" /* TECH_PREVIEW */) {
+            continue;
+          }
+          if (mode === "merge" /* MERGE */ || mode === "root_merge" /* ROOT_MERGE */) {
+            _copyTocDir(includeTocPath, tocDir);
+          }
+          addIncludeTocPath(includeTocPath);
+          let includedTocItems = (item.items || []).concat(includeToc.items);
+          const baseTocDir = mode === "link" /* LINK */ ? includeTocDir : tocDir;
+          includedTocItems = yield processTocItems(path, includedTocItems, baseTocDir, sourcesDir, vars);
+          if (mode === "link" /* LINK */) {
+            includedTocItems = _replaceIncludesHrefs(includedTocItems, includeTocDir, tocDir);
+          }
+          if (item.name) {
+            item.items = includedTocItems;
+          } else {
+            includedInlineItems = includedTocItems;
+          }
+        } catch (err) {
+          const message = `Error while including toc: ${(0, import_chalk2.bold)(includeTocPath)} to ${(0, import_chalk2.bold)((0, import_path13.join)(tocDir, "toc.yaml"))}`;
+          import_log3.default.error(message);
+          continue;
+        } finally {
+          delete item.include;
+        }
+      } else if (item.items) {
+        item.items = yield processTocItems(path, item.items, tocDir, sourcesDir, vars);
+      }
+      if (includedInlineItems) {
+        result.push(...includedInlineItems);
+      } else {
+        result.push(item);
+      }
+    }
+    return result;
+  });
+}
+function getTocDir(pagePath) {
+  const { input: inputFolderPath } = argv_default.getConfig();
+  const tocDir = (0, import_path13.dirname)(pagePath);
+  const tocPath = (0, import_path13.resolve)(tocDir, "toc.yaml");
+  if (!tocDir.includes(inputFolderPath)) {
+    throw new Error("Error while finding toc dir");
+  }
+  if ((0, import_fs4.existsSync)(tocPath)) {
+    return tocDir;
+  }
+  return getTocDir(tocDir);
+}
+function setNavigationPaths(paths) {
+  navigationPaths = paths;
+}
+var tocs_default = {
+  add,
+  getForPath,
+  getNavigationPaths,
+  getTocDir,
+  getIncludedTocPaths,
+  setNavigationPaths
+};
+
+// src/services/preset.ts
+var import_path14 = require("path");
+var presetStorage = /* @__PURE__ */ new Map();
+function add2(parsedPreset, path, varsPreset) {
+  const combinedValues = __spreadValues(__spreadValues({}, parsedPreset.default || {}), parsedPreset[varsPreset] || {});
+  const key = (0, import_path14.dirname)((0, import_path14.normalize)(path));
+  presetStorage.set(key, combinedValues);
+}
+function get(path) {
+  let combinedValues = {};
+  let localPath = (0, import_path14.normalize)(path);
+  while (localPath !== ".") {
+    const presetValues = presetStorage.get(localPath) || {};
+    localPath = (0, import_path14.dirname)(localPath);
+    combinedValues = __spreadValues(__spreadValues({}, presetValues), combinedValues);
+  }
+  combinedValues = __spreadValues(__spreadValues({}, presetStorage.get(".")), combinedValues);
+  return combinedValues;
+}
+function getPresetStorage() {
+  return presetStorage;
+}
+function setPresetStorage(preset) {
+  presetStorage = preset;
+}
+var preset_default = {
+  add: add2,
+  get,
+  getPresetStorage,
+  setPresetStorage
+};
+
+// src/services/argv.ts
+var import_path15 = require("path");
+var import_fs5 = require("fs");
+var _argv;
+function getConfig() {
+  return _argv;
+}
+function init2(argv) {
+  _argv = __spreadProps(__spreadValues({}, argv), {
+    ignore: Array.isArray(argv.ignore) ? argv.ignore : []
+  });
+  if (argv.vars) {
+    _argv.vars = JSON.parse(argv.vars);
+  }
+  try {
+    const ignorefile = (0, import_fs5.readFileSync)((0, import_path15.join)(_argv.rootInput, ".yfmignore"), "utf8");
+    const ignore = ignorefile.split("\n");
+    _argv.ignore = _argv.ignore.concat(ignore);
+  } catch (e) {
+  }
+}
+function set(argv) {
+  _argv = argv;
+}
+var argv_default = {
+  getConfig,
+  init: init2,
+  set
+};
+
+// src/services/leading.ts
+var import_path16 = require("path");
+var import_fs6 = require("fs");
+var import_js_yaml5 = require("js-yaml");
+var import_log4 = __toESM(require("@doc-tools/transform/lib/log"));
+function filterFile(path) {
+  var _a, _b;
+  const {
+    input: inputFolderPath,
+    vars
+  } = argv_default.getConfig();
+  const pathToDir = (0, import_path16.dirname)(path);
+  const filePath = (0, import_path16.resolve)(inputFolderPath, path);
+  const content = (0, import_fs6.readFileSync)(filePath, "utf8");
+  const parsedIndex = (0, import_js_yaml5.load)(content);
+  const combinedVars = __spreadValues(__spreadValues({}, preset_default.get(pathToDir)), vars);
+  try {
+    const title = firstFilterTextItems(
+      parsedIndex.title,
+      combinedVars,
+      { resolveConditions: true }
+    );
+    parsedIndex.title = liquidField(title, combinedVars, path);
+    const description6 = filterTextItems(
+      parsedIndex.description,
+      combinedVars,
+      { resolveConditions: true }
+    );
+    parsedIndex.description = liquidFields(description6, combinedVars, path);
+    if ((_a = parsedIndex.meta) == null ? void 0 : _a.title) {
+      const metaTitle = firstFilterTextItems(
+        parsedIndex.meta.title,
+        combinedVars,
+        { resolveConditions: true }
+      );
+      parsedIndex.meta.title = liquidField(metaTitle, combinedVars, path);
+    }
+    if ((_b = parsedIndex.meta) == null ? void 0 : _b.description) {
+      const metaDescription = firstFilterTextItems(
+        parsedIndex.meta.description,
+        combinedVars,
+        { resolveConditions: true }
+      );
+      parsedIndex.meta.description = liquidField(metaDescription, combinedVars, path);
+    }
+    if (parsedIndex.nav) {
+      const navTitle = firstFilterTextItems(
+        parsedIndex.nav.title,
+        combinedVars,
+        { resolveConditions: true }
+      );
+      parsedIndex.nav.title = liquidField(navTitle, combinedVars, path);
+    }
+    parsedIndex.links = filterFiles(parsedIndex.links, "links", combinedVars, { resolveConditions: true });
+    parsedIndex.links.forEach((link) => {
+      if (link.title) {
+        link.title = liquidField(link.title, combinedVars, path);
+      }
+      if (link.description) {
+        link.description = liquidField(link.description, combinedVars, path);
+      }
+    });
+    (0, import_fs6.writeFileSync)(filePath, (0, import_js_yaml5.dump)(parsedIndex));
+  } catch (error) {
+    import_log4.default.error(`Error while filtering index file: ${path}. Error message: ${error}`);
+  }
+}
+var leading_default = {
+  filterFile
+};
+
+// src/services/plugins.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  getCollectOfPlugins: () => getCollectOfPlugins,
+  getCustomLintRules: () => getCustomLintRules,
+  getDefaultLintConfig: () => getDefaultLintConfig,
+  getHeadContent: () => getHeadContent,
+  getPlugins: () => getPlugins,
+  setPlugins: () => setPlugins
+});
+var plugins;
+var collectionOfPlugins;
+function setPlugins() {
+  plugins = getAllPlugins();
+  collectionOfPlugins = makeCollectOfPlugins();
+}
+function getPlugins() {
+  return plugins;
+}
+function getCollectOfPlugins() {
+  return collectionOfPlugins;
+}
+function makeCollectOfPlugins() {
+  const pluginsWithCollect = plugins.filter((plugin) => {
+    return typeof plugin.collect === "function";
+  });
+  return (output, options) => {
+    let collectsOutput = output;
+    pluginsWithCollect.forEach((plugin) => {
+      const collectOutput = plugin.collect(collectsOutput, options);
+      collectsOutput = typeof collectOutput === "string" ? collectOutput : collectsOutput;
+    });
+    return collectsOutput;
+  };
+}
+function getAllPlugins() {
+  const customPlugins = getCustomPlugins();
+  return [...YFM_PLUGINS, ...customPlugins];
+}
+function getCustomPlugins() {
+  try {
+    const customPlugins = require(require.resolve("./plugins"));
+    return Array.isArray(customPlugins) ? customPlugins : [];
+  } catch (e) {
+    return [];
+  }
+}
+function getHeadContent() {
+  try {
+    return require(require.resolve("./head-content.js"));
+  } catch (e) {
+    return "";
+  }
+}
+function getCustomLintRules() {
+  try {
+    return require(require.resolve("./lint-rules"));
+  } catch (e) {
+    return [];
+  }
+}
+function getDefaultLintConfig() {
+  try {
+    return require(require.resolve("./default-lint-config"));
+  } catch (e) {
+    return void 0;
+  }
+}
+
+// src/cmd/build/index.ts
+var import_includer = __toESM(require("@diplodoc/openapi-extension/includer"));
+
+// src/steps/processAssets.ts
+var import_walk_sync2 = __toESM(require("walk-sync"));
+var import_shelljs3 = __toESM(require("shelljs"));
+var import_client3 = __toESM(require_client());
+function processAssets(outputBundlePath) {
+  const {
+    input: inputFolderPath,
+    output: outputFolderPath
+  } = argv_default.getConfig();
+  const assetFilePath = (0, import_walk_sync2.default)(inputFolderPath, {
+    directories: false,
+    includeBasePath: false,
+    ignore: [
+      "**/*.yaml",
+      "**/*.md"
+    ]
+  });
+  copyFiles(inputFolderPath, outputFolderPath, assetFilePath);
+  import_shelljs3.default.mkdir("-p", outputBundlePath);
+  for (const path of Object.values(import_client3.default.dst)) {
+    import_shelljs3.default.cp(path, outputBundlePath);
+  }
+}
+
+// src/steps/processExcludedFiles.ts
+var import_path17 = require("path");
+var import_walk_sync3 = __toESM(require("walk-sync"));
+var import_shelljs4 = __toESM(require("shelljs"));
+function processExcludedFiles() {
+  const {
+    input: inputFolderPath,
+    output: outputFolderPath,
+    ignore
+  } = argv_default.getConfig();
+  const allContentFiles = (0, import_walk_sync3.default)(inputFolderPath, {
+    directories: false,
+    includeBasePath: true,
+    globs: [
+      "**/*.md",
+      "**/index.yaml",
+      ...ignore
+    ],
+    // Ignores service directories like "_includes", "_templates" and etc.
+    ignore: ["**/_*/**/*"]
+  });
+  const navigationPaths2 = tocs_default.getNavigationPaths().map((filePath) => convertBackSlashToSlash((0, import_path17.resolve)(inputFolderPath, filePath)));
+  const tocSpecifiedFiles = new Set(navigationPaths2);
+  const excludedFiles = allContentFiles.filter((filePath) => !tocSpecifiedFiles.has(filePath));
+  import_shelljs4.default.rm("-f", excludedFiles);
+  const includedTocPaths2 = tocs_default.getIncludedTocPaths().map((filePath) => {
+    const relativeTocPath = (0, import_path17.relative)(inputFolderPath, filePath);
+    const destTocPath = (0, import_path17.resolve)(outputFolderPath, relativeTocPath);
+    return convertBackSlashToSlash(destTocPath);
+  });
+  import_shelljs4.default.rm("-rf", includedTocPaths2);
+}
+
+// src/steps/processLogs.ts
+var import_log5 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_uniq = __toESM(require("lodash/uniq"));
+function processLogs(inputFolder) {
+  const replacementRegExp = new RegExp(inputFolder, "ig");
+  const { info, warn, error } = import_log5.default.get();
+  const outputLogs = (0, import_uniq.default)([
+    "",
+    ...info,
+    "",
+    ...warn,
+    "",
+    ...error,
+    ""
+  ]);
+  for (const outputLog of outputLogs) {
+    const preparedLog = outputLog.replace(replacementRegExp, "");
+    console.log(preparedLog);
+  }
+}
+
+// src/steps/processPages.ts
+var import_path22 = require("path");
+var import_shelljs6 = __toESM(require("shelljs"));
+var import_fs10 = require("fs");
+var import_chalk4 = require("chalk");
+var import_js_yaml7 = require("js-yaml");
+var import_async = require("async");
+var import_log11 = __toESM(require("@doc-tools/transform/lib/log"));
+
+// src/resolvers/md2md.ts
+var import_fs7 = require("fs");
+var import_path18 = require("path");
+var import_shelljs5 = __toESM(require("shelljs"));
+var import_log6 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_liquid3 = __toESM(require("@doc-tools/transform/lib/liquid"));
+function resolveMd2Md(options) {
+  return __async(this, null, function* () {
+    const { inputPath, outputPath, metadata } = options;
+    const { input, output } = argv_default.getConfig();
+    const resolvedInputPath = (0, import_path18.resolve)(input, inputPath);
+    const vars = getVarsPerFile(inputPath);
+    const content = yield getContentWithUpdatedMetadata(
+      (0, import_fs7.readFileSync)(resolvedInputPath, "utf8"),
+      metadata,
+      vars.__system
+    );
+    const { result, changelogs } = transformMd2Md(content, {
+      path: resolvedInputPath,
+      destPath: outputPath,
+      root: (0, import_path18.resolve)(input),
+      destRoot: (0, import_path18.resolve)(output),
+      collectOfPlugins: plugins_exports.getCollectOfPlugins(),
+      vars,
+      log: import_log6.default,
+      copyFile
+    });
+    (0, import_fs7.writeFileSync)(outputPath, result);
+    if (changelogs == null ? void 0 : changelogs.length) {
+      const mdFilename = (0, import_path18.basename)(outputPath, (0, import_path18.extname)(outputPath));
+      const outputDir = (0, import_path18.dirname)(outputPath);
+      changelogs.forEach((changes, index) => {
+        let changesName;
+        const changesDate = changes.date;
+        const changesIdx = changes.index;
+        if (typeof changesIdx === "number") {
+          changesName = String(changesIdx);
+        }
+        if (!changesName && changesDate && /^\d{4}/.test(changesDate)) {
+          changesName = Math.trunc(new Date(changesDate).getTime() / 1e3);
+        }
+        if (!changesName) {
+          changesName = `name-${mdFilename}-${String(changelogs.length - index).padStart(3, "0")}`;
+        }
+        const changesPath = (0, import_path18.join)(outputDir, `changes-${changesName}.json`);
+        if ((0, import_fs7.existsSync)(changesPath)) {
+          throw new Error(`Changelog ${changesPath} already exists!`);
+        }
+        (0, import_fs7.writeFileSync)(changesPath, JSON.stringify(__spreadProps(__spreadValues({}, changes), {
+          source: mdFilename
+        })));
+      });
+    }
+    logger.info(inputPath, PROCESSING_FINISHED);
+    return void 0;
+  });
+}
+function copyFile(targetPath, targetDestPath, options) {
+  import_shelljs5.default.mkdir("-p", (0, import_path18.dirname)(targetDestPath));
+  if (options) {
+    const sourceIncludeContent = (0, import_fs7.readFileSync)(targetPath, "utf8");
+    const { result } = transformMd2Md(sourceIncludeContent, options);
+    (0, import_fs7.writeFileSync)(targetDestPath, result);
+  } else {
+    import_shelljs5.default.cp(targetPath, targetDestPath);
+  }
+}
+function liquidMd2Md(input, vars, path) {
+  const {
+    applyPresets,
+    resolveConditions,
+    conditionsInCode
+  } = argv_default.getConfig();
+  return (0, import_liquid3.default)(input, vars, path, {
+    conditions: resolveConditions,
+    substitutions: applyPresets,
+    conditionsInCode,
+    withSourceMap: true,
+    keepNotVar: true
+  });
+}
+function transformMd2Md(input, options) {
+  const {
+    disableLiquid
+  } = argv_default.getConfig();
+  const {
+    vars = {},
+    path,
+    root,
+    destPath,
+    destRoot,
+    collectOfPlugins,
+    log: pluginLog,
+    copyFile: pluginCopyFile
+  } = options;
+  let output = input;
+  const changelogs = [];
+  if (!disableLiquid) {
+    const liquidResult = liquidMd2Md(input, vars, path);
+    output = liquidResult.output;
+  }
+  if (collectOfPlugins) {
+    output = collectOfPlugins(output, {
+      vars,
+      path,
+      root,
+      destPath,
+      destRoot,
+      log: pluginLog,
+      copyFile: pluginCopyFile,
+      collectOfPlugins,
+      changelogs,
+      extractChangelogs: true
+    });
+  }
+  return {
+    result: output,
+    changelogs,
+    logs: pluginLog.get()
+  };
+}
+
+// src/resolvers/md2html.ts
+var import_path19 = require("path");
+var import_fs8 = require("fs");
+var import_js_yaml6 = __toESM(require("js-yaml"));
+var import_transform = __toESM(require("@doc-tools/transform"));
+var import_log7 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_liquid4 = __toESM(require("@doc-tools/transform/lib/liquid"));
+var FileTransformer = {
+  ".yaml": YamlFileTransformer,
+  ".md": MdFileTransformer
+};
+var fixRelativePath = (relativeTo) => (path) => {
+  return (0, import_path19.join)(getAssetsPublicPath(relativeTo), path);
+};
+function resolveMd2HTML(options) {
+  return __async(this, null, function* () {
+    var _a;
+    const { inputPath, fileExtension, outputPath, outputBundlePath, metadata } = options;
+    const pathToDir = (0, import_path19.dirname)(inputPath);
+    const toc = tocs_default.getForPath(inputPath) || null;
+    const tocBase = toc && toc.base ? toc.base : "";
+    const pathToFileDir = pathToDir === tocBase ? "" : pathToDir.replace(`${tocBase}${import_path19.sep}`, "");
+    const relativePathToIndex = (0, import_path19.relative)(pathToDir, `${tocBase}${import_path19.sep}`);
+    const { input, lang, allowCustomResources } = argv_default.getConfig();
+    const resolvedPath = (0, import_path19.resolve)(input, inputPath);
+    const content = (0, import_fs8.readFileSync)(resolvedPath, "utf8");
+    const transformFn = FileTransformer[fileExtension];
+    const { result } = transformFn(content, { path: inputPath });
+    const updatedMetadata = metadata && metadata.isContributorsEnabled ? yield getUpdatedMetadata(metadata, content, result == null ? void 0 : result.meta) : result.meta;
+    const fileMeta = fileExtension === ".yaml" ? (_a = result.data.meta) != null ? _a : {} : updatedMetadata;
+    if (allowCustomResources) {
+      const { script, style } = (metadata == null ? void 0 : metadata.resources) || {};
+      fileMeta.style = (fileMeta.style || []).concat(style || []).map(fixRelativePath(inputPath));
+      fileMeta.script = (fileMeta.script || []).concat(script || []).map(fixRelativePath(inputPath));
+    } else {
+      fileMeta.style = [];
+      fileMeta.script = [];
+    }
+    const props = {
+      data: __spreadProps(__spreadValues({
+        leading: inputPath.endsWith(".yaml"),
+        toc: transformToc(toc, pathToDir) || {}
+      }, result), {
+        meta: fileMeta
+      }),
+      router: {
+        pathname: (0, import_path19.join)(relativePathToIndex, pathToFileDir, (0, import_path19.basename)(outputPath))
+      },
+      lang: lang || "ru" /* RU */
+    };
+    const outputDir = (0, import_path19.dirname)(outputPath);
+    const relativePathToBundle = (0, import_path19.relative)((0, import_path19.resolve)(outputDir), (0, import_path19.resolve)(outputBundlePath));
+    const outputFileContent = generateStaticMarkup(props, relativePathToBundle);
+    (0, import_fs8.writeFileSync)(outputPath, outputFileContent);
+    logger.info(inputPath, PROCESSING_FINISHED);
+    return props;
+  });
+}
+function YamlFileTransformer(content) {
+  var _a;
+  let data = null;
+  try {
+    data = import_js_yaml6.default.load(content);
+  } catch (error) {
+    import_log7.default.error(`Yaml transform has been failed. Error: ${error}`);
+  }
+  if (!data) {
+    return {
+      result: { data: {} }
+    };
+  }
+  const links2 = (_a = data == null ? void 0 : data.links) == null ? void 0 : _a.map(
+    (link) => link.href ? __spreadProps(__spreadValues({}, link), { href: link.href.replace(/.md$/gmu, ".html") }) : link
+  );
+  if (links2) {
+    data.links = links2;
+  }
+  return {
+    result: { data }
+  };
+}
+function liquidMd2Html(input, vars, path) {
+  const { conditionsInCode } = argv_default.getConfig();
+  return (0, import_liquid4.default)(input, vars, path, {
+    conditionsInCode,
+    withSourceMap: true
+  });
+}
+function MdFileTransformer(content, transformOptions) {
+  const _a = argv_default.getConfig(), { input } = _a, options = __objRest(_a, ["input"]);
+  const { path: filePath } = transformOptions;
+  const plugins2 = plugins_exports.getPlugins();
+  const vars = getVarsPerFile(filePath);
+  const root = (0, import_path19.resolve)(input);
+  const path = (0, import_path19.resolve)(input, filePath);
+  return (0, import_transform.default)(content, __spreadProps(__spreadValues({}, options), {
+    plugins: plugins2,
+    vars,
+    root,
+    path,
+    assetsPublicPath: getAssetsPublicPath(filePath),
+    getVarsPerFile: getVarsPerRelativeFile,
+    extractTitle: true
+  }));
+}
+
+// src/resolvers/lintPage.ts
+var import_path20 = require("path");
+var import_log8 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_yfmlint = __toESM(require("@doc-tools/transform/lib/yfmlint"));
+var import_fs9 = require("fs");
+var import_chalk3 = require("chalk");
+var FileLinter = {
+  ".md": MdFileLinter
+};
+function lintPage(options) {
+  const { inputPath, fileExtension, onFinish } = options;
+  const { input } = argv_default.getConfig();
+  const resolvedPath = (0, import_path20.resolve)(input, inputPath);
+  try {
+    const content = (0, import_fs9.readFileSync)(resolvedPath, "utf8");
+    const lintFn = FileLinter[fileExtension];
+    if (!lintFn) {
+      return;
+    }
+    lintFn(content, { path: inputPath });
+  } catch (e) {
+    const message = `No such file or has no access to ${(0, import_chalk3.bold)(resolvedPath)}`;
+    console.error(message, e);
+    import_log8.default.error(message);
+  }
+  if (onFinish) {
+    onFinish();
+  }
+}
+function MdFileLinter(content, lintOptions) {
+  const _a = argv_default.getConfig(), {
+    input,
+    lintConfig,
+    disableLiquid,
+    outputFormat
+  } = _a, options = __objRest(_a, [
+    "input",
+    "lintConfig",
+    "disableLiquid",
+    "outputFormat"
+  ]);
+  const { path: filePath } = lintOptions;
+  const plugins2 = outputFormat === "md" ? [] : plugins_exports.getPlugins();
+  const vars = getVarsPerFile(filePath);
+  const root = (0, import_path20.resolve)(input);
+  const path = (0, import_path20.resolve)(input, filePath);
+  let preparedContent = content;
+  const assetsPublicPath = (0, import_path20.relative)((0, import_path20.dirname)(path), root);
+  const lintMarkdown = function lintMarkdown2(opts) {
+    const { input: localInput, path: localPath, sourceMap: sourceMap2 } = opts;
+    const pluginOptions = __spreadProps(__spreadValues({}, options), {
+      vars,
+      root,
+      path: localPath,
+      lintMarkdown: lintMarkdown2,
+      // Should pass the function for linting included files
+      assetsPublicPath,
+      disableLiquid,
+      log: import_log8.default,
+      getVarsPerFile: getVarsPerRelativeFile
+    });
+    (0, import_yfmlint.default)({
+      input: localInput,
+      lintConfig,
+      pluginOptions,
+      plugins: plugins2,
+      defaultLintConfig: plugins_exports.getDefaultLintConfig(),
+      customLintRules: plugins_exports.getCustomLintRules(),
+      sourceMap: sourceMap2
+    });
+  };
+  let sourceMap;
+  if (!disableLiquid) {
+    let liquidResult;
+    if (outputFormat === "md") {
+      liquidResult = liquidMd2Md(content, vars, path);
+    } else {
+      liquidResult = liquidMd2Html(content, vars, path);
+    }
+    preparedContent = liquidResult.output;
+    sourceMap = liquidResult.sourceMap;
+  }
+  lintMarkdown({
+    input: preparedContent,
+    path,
+    sourceMap
+  });
+}
+
+// src/vcs-connector/github.ts
+var import_core = require("@octokit/core");
+var import_path21 = require("path");
+var import_simple_git = __toESM(require("simple-git"));
+var import_minimatch = require("minimatch");
+
+// src/vcs-connector/client/github.ts
+var import_log10 = __toESM(require("@doc-tools/transform/lib/log"));
+
+// src/vcs-connector/connector-validator.ts
+var import_log9 = __toESM(require("@doc-tools/transform/lib/log"));
+var githubConnectorValidator = {
+  ["endpoint" /* ENDPOINT */]: {
+    warnMessage: `'${"endpoint" /* ENDPOINT */}' must be provided for GitHub repo.`,
+    validateFn: notEmptyValue,
+    defaultValue: process.env.GITHUB_BASE_URL
+  },
+  ["token" /* TOKEN */]: {
+    warnMessage: `'${"token" /* TOKEN */}' must be provided for GitHub repo.`,
+    validateFn: notEmptyValue,
+    defaultValue: process.env.GITHUB_TOKEN
+  },
+  ["owner" /* OWNER */]: {
+    warnMessage: `'${"owner" /* OWNER */}' must be provided for GitHub repo.`,
+    validateFn: notEmptyValue,
+    defaultValue: process.env.GITHUB_OWNER
+  },
+  ["repo" /* REPO */]: {
+    warnMessage: `'${"repo" /* REPO */}' must be provided for GitHub repo.`,
+    validateFn: notEmptyValue,
+    defaultValue: process.env.GITHUB_REPO
+  }
+};
+var connectorValidator = {
+  "type": {
+    warnMessage: "'type' must be provided for repo.",
+    validateFn: notEmptyValue
+  },
+  ["github" /* GITHUB */]: {
+    warnMessage: `'${"github" /* GITHUB */}' object must be filled needed fields.`,
+    validateFn: notEmptyObject,
+    relatedValidator: githubConnectorValidator
+  }
+};
+function notEmptyObject(filed) {
+  if (typeof filed === "object") {
+    return Boolean(filed && Object.getOwnPropertyNames(filed).length);
+  }
+  return false;
+}
+function notEmptyValue(value) {
+  if (typeof value === "string") {
+    return Boolean(value);
+  }
+  return false;
+}
+function validateConnectorFields(sourceType, fieldNames, repoProperties) {
+  var _a;
+  const repoValidator = connectorValidator[sourceType];
+  if (!repoValidator) {
+    import_log9.default.error(`Invalid repo type: ${repoValidator}`);
+    return {};
+  }
+  const isValidRepo = repoValidator.validateFn(repoProperties && repoProperties[sourceType]);
+  const relatedRepoValidator = repoValidator.relatedValidator;
+  if (!repoProperties || !isValidRepo || !relatedRepoValidator) {
+    createLog(repoValidator);
+    return {};
+  }
+  let isValidProperties = true;
+  const validatedFields = {};
+  for (const property of fieldNames) {
+    const propertyValidator = relatedRepoValidator[property];
+    if (!propertyValidator) {
+      import_log9.default.warn(`The property '${property}' doesn't exist in ${sourceType} repo.`);
+      continue;
+    }
+    const propertyValue = propertyValidator.defaultValue || ((_a = repoProperties[sourceType]) == null ? void 0 : _a[property]);
+    if (!propertyValidator.validateFn(propertyValue)) {
+      createLog(propertyValidator);
+      isValidProperties = false;
+    }
+    validatedFields[property] = propertyValue;
+  }
+  if (isValidProperties) {
+    return validatedFields;
+  }
+  import_log9.default.warn(getMsg\u0421onfigurationMustBeProvided(sourceType));
+  return {};
+}
+function createLog(validator) {
+  if (validator.errorMessage) {
+    return import_log9.default.error(validator.errorMessage);
+  }
+  if (validator.warnMessage) {
+    return import_log9.default.warn(validator.warnMessage);
+  }
+  throw new Error(`Invalid validator: ${JSON.stringify(validator)}.`);
+}
+
+// src/vcs-connector/client/github.ts
+function getRepoUser(octokit, username) {
+  return __async(this, null, function* () {
+    try {
+      const user = yield octokit.request("GET /users/{username}", {
+        username
+      });
+      return user.data;
+    } catch (error) {
+      import_log10.default.warn(`Getting user for GitHub has been failed. Username: ${username}. Error: ${error}`);
+      return null;
+    }
+  });
+}
+function getRepoCommitByHash(httpClientByToken, hashCommit) {
+  return __async(this, null, function* () {
+    const { connector } = argv_default.getConfig();
+    const neededProperties = ["owner" /* OWNER */, "repo" /* REPO */];
+    const validatedFileds = validateConnectorFields("github" /* GITHUB */, neededProperties, connector);
+    if (Object.keys(validatedFileds).length === 0) {
+      return null;
+    }
+    try {
+      const commit = yield httpClientByToken.request("GET /repos/{owner}/{repo}/commits/{commit_sha}", {
+        owner: validatedFileds["owner" /* OWNER */],
+        repo: validatedFileds["repo" /* REPO */],
+        commit_sha: hashCommit
+      });
+      return commit.data;
+    } catch (error) {
+      import_log10.default.warn(`Getting commit by sha has been failed for GitHub. SHA commit: ${hashCommit}. Error: ${error}`);
+      return null;
+    }
+  });
+}
+var github_default = {
+  getRepoUser,
+  getRepoCommitByHash
+};
+
+// src/vcs-connector/github.ts
+var import_process2 = __toESM(require("process"));
+var authorByGitEmail = /* @__PURE__ */ new Map();
+var authorByPath = /* @__PURE__ */ new Map();
+var contributorsByPath = /* @__PURE__ */ new Map();
+var contributorsData = /* @__PURE__ */ new Map();
+function getGitHubVCSConnector() {
+  return __async(this, null, function* () {
+    const { contributors } = argv_default.getConfig();
+    const httpClientByToken = getHttpClientByToken();
+    if (!httpClientByToken) {
+      return void 0;
+    }
+    let addNestedContributorsForPath = () => {
+    };
+    let getContributorsByPath = () => Promise.resolve({});
+    const getExternalAuthorByPath = (path) => {
+      var _a;
+      return (_a = authorByPath.get(path)) != null ? _a : null;
+    };
+    if (contributors) {
+      yield getAllContributorsTocFiles(httpClientByToken);
+      addNestedContributorsForPath = (path, nestedContributors) => addNestedContributorsForPathFunction(path, nestedContributors);
+      getContributorsByPath = (path) => __async(this, null, function* () {
+        return getFileContributorsByPath(path);
+      });
+    }
+    return {
+      getExternalAuthorByPath,
+      addNestedContributorsForPath,
+      getContributorsByPath,
+      getUserByLogin: (login) => getUserByLogin(httpClientByToken, login)
+    };
+  });
+}
+function getHttpClientByToken() {
+  const { connector, contributors } = argv_default.getConfig();
+  if (!contributors) {
+    return null;
+  }
+  const neededProperties = ["token" /* TOKEN */, "endpoint" /* ENDPOINT */];
+  const validatedFileds = validateConnectorFields("github" /* GITHUB */, neededProperties, connector);
+  if (Object.keys(validatedFileds).length === 0) {
+    return null;
+  }
+  const octokit = new import_core.Octokit({
+    auth: validatedFileds["token" /* TOKEN */],
+    baseUrl: validatedFileds["endpoint" /* ENDPOINT */]
+  });
+  return octokit;
+}
+function getAllContributorsTocFiles(httpClientByToken) {
+  return __async(this, null, function* () {
+    const { rootInput } = argv_default.getConfig();
+    const options = {
+      baseDir: rootInput
+    };
+    logger.info("", GETTING_ALL_CONTRIBUTORS);
+    const masterDir = "./_yfm-master";
+    const tmpMasterBranch = "yfm-tmp-master";
+    try {
+      yield (0, import_simple_git.default)(options).raw("worktree", "add", "-b", tmpMasterBranch, masterDir, "origin/master");
+      const fullRepoLogString = yield (0, import_simple_git.default)({
+        baseDir: (0, import_path21.join)(rootInput, masterDir)
+      }).raw(
+        "log",
+        `${FIRST_COMMIT_FROM_ROBOT_IN_GITHUB}..HEAD`,
+        "--pretty=format:%ae, %an, %H",
+        "--name-only"
+      );
+      const repoLogs = fullRepoLogString.split("\n\n");
+      if (import_process2.default.env.ENABLE_EXPERIMANTAL_AUTHORS) {
+        const fullAuthorRepoLogString = yield (0, import_simple_git.default)({
+          baseDir: (0, import_path21.join)(rootInput, masterDir)
+        }).raw(
+          "log",
+          `${FIRST_COMMIT_FROM_ROBOT_IN_GITHUB}..HEAD`,
+          "--diff-filter=A",
+          "--pretty=format:%ae;%an;%H",
+          "--name-only"
+        );
+        const authorRepoLog = fullAuthorRepoLogString.split("\n\n");
+        yield matchAuthorsForEachPath(authorRepoLog, httpClientByToken);
+      }
+      yield matchContributionsForEachPath(repoLogs, httpClientByToken);
+    } finally {
+      yield (0, import_simple_git.default)(options).raw("worktree", "remove", masterDir);
+      yield (0, import_simple_git.default)(options).raw("branch", "-d", tmpMasterBranch);
+    }
+    logger.info("", ALL_CONTRIBUTORS_RECEIVED);
+  });
+}
+function matchContributionsForEachPath(repoLogs, httpClientByToken) {
+  return __async(this, null, function* () {
+    for (const repoLog of repoLogs) {
+      if (!repoLog) {
+        continue;
+      }
+      const dataArray = repoLog.split("\n");
+      const userData = dataArray[0];
+      const [email, name4, hashCommit] = userData.split(", ");
+      if (shouldAuthorBeIgnored({ email, name: name4 })) {
+        continue;
+      }
+      const hasContributorData = contributorsData.get(email);
+      let contributorDataByHash;
+      if (hasContributorData === void 0) {
+        logger.info("Contributors: Getting data for", email);
+        contributorDataByHash = yield getContributorDataByHashCommit(httpClientByToken, hashCommit);
+        if (contributorDataByHash) {
+          const paths = dataArray.splice(1);
+          addContributorForPath(paths, {
+            [email]: contributorDataByHash
+          });
+        }
+        contributorsData.set(email, contributorDataByHash);
+      } else if (hasContributorData) {
+        const paths = dataArray.splice(1);
+        addContributorForPath(paths, {
+          [email]: hasContributorData
+        });
+      }
+    }
+  });
+}
+function matchAuthorsForEachPath(authorRepoLogs, httpClientByToken) {
+  return __async(this, null, function* () {
+    for (const repoLog of authorRepoLogs) {
+      if (!repoLog) {
+        continue;
+      }
+      const dataArray = repoLog.split("\n");
+      const [userData, ...paths] = dataArray;
+      const [email, name4, hashCommit] = userData.split(";");
+      if (shouldAuthorBeIgnored({ email, name: name4 })) {
+        continue;
+      }
+      yield getAuthorByPaths({ email, hashCommit }, paths, httpClientByToken);
+    }
+  });
+}
+function getContributorDataByHashCommit(httpClientByToken, hashCommit) {
+  return __async(this, null, function* () {
+    const repoCommit = yield github_default.getRepoCommitByHash(httpClientByToken, hashCommit);
+    if (!repoCommit) {
+      return null;
+    }
+    const { author, commit } = repoCommit;
+    if (!author) {
+      return null;
+    }
+    const { avatar_url: avatar, html_url: url2, login } = author;
+    return {
+      avatar,
+      email: commit.author.email,
+      login,
+      name: commit.author.name,
+      url: url2
+    };
+  });
+}
+function getAuthorByPaths(commitInfo, paths, httpClientByToken) {
+  return __async(this, null, function* () {
+    for (const path of paths) {
+      if (!path) {
+        continue;
+      }
+      const normalizePath = (0, import_path21.normalize)(addSlashPrefix(path));
+      const { email, hashCommit } = commitInfo;
+      let authorToReturn = authorByGitEmail.get(email) || null;
+      if (!authorToReturn) {
+        logger.info("Authors: Getting data for", email);
+        const repoCommit = yield github_default.getRepoCommitByHash(httpClientByToken, hashCommit);
+        if (!repoCommit) {
+          continue;
+        }
+        const { author, commit } = repoCommit;
+        if (!author) {
+          continue;
+        }
+        const { avatar_url: avatar, html_url: url2, login } = author;
+        authorToReturn = {
+          avatar,
+          email: commit.author.email,
+          login,
+          name: commit.author.name,
+          url: url2
+        };
+        authorByGitEmail.set(email, authorToReturn);
+      }
+      authorByPath.set(normalizePath, authorToReturn);
+    }
+  });
+}
+function getFileContributorsByPath(path) {
+  return __async(this, null, function* () {
+    if (contributorsData.size === 0 || !contributorsByPath.has(path)) {
+      return {};
+    }
+    return contributorsByPath.get(path);
+  });
+}
+function getUserByLogin(octokit, userLogin) {
+  return __async(this, null, function* () {
+    const user = yield github_default.getRepoUser(octokit, userLogin);
+    if (!user) {
+      return null;
+    }
+    const { avatar_url: avatar, html_url: url2, email, login, name: name4 } = user;
+    return {
+      avatar,
+      email,
+      login,
+      name: name4,
+      url: url2
+    };
+  });
+}
+function addNestedContributorsForPathFunction(path, nestedContributors) {
+  addContributorForPath([path], nestedContributors, true);
+}
+function addContributorForPath(paths, newContributor, hasIncludes = false) {
+  paths.forEach((path) => {
+    const normalizePath = (0, import_path21.normalize)(addSlashPrefix(path));
+    if (!contributorsByPath.has(normalizePath)) {
+      contributorsByPath.set(normalizePath, {
+        contributors: newContributor,
+        hasIncludes
+      });
+      return;
+    }
+    const oldContributors = contributorsByPath.get(normalizePath);
+    contributorsByPath.set(normalizePath, {
+      contributors: __spreadValues(__spreadValues({}, oldContributors == null ? void 0 : oldContributors.contributors), newContributor),
+      hasIncludes
+    });
+  });
+}
+function shouldAuthorBeIgnored({ email, name: name4 }) {
+  if (!(email || name4)) {
+    return false;
+  }
+  const { ignoreAuthorPatterns } = argv_default.getConfig();
+  if (!ignoreAuthorPatterns) {
+    return false;
+  }
+  for (const pattern of ignoreAuthorPatterns) {
+    if (email && (0, import_minimatch.minimatch)(email, pattern)) {
+      return true;
+    }
+    if (name4 && (0, import_minimatch.minimatch)(name4, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+var github_default2 = getGitHubVCSConnector;
+
+// src/vcs-connector/index.ts
+function getVCSConnector() {
+  return __async(this, null, function* () {
+    const { connector } = argv_default.getConfig();
+    const connectorType = process.env.VCS_CONNECTOR_TYPE || connector && connector.type;
+    switch (connectorType) {
+      case "github" /* GITHUB */:
+        return github_default2();
+      default:
+        return void 0;
+    }
+  });
+}
+
+// src/steps/processPages.ts
+var singlePageResults = {};
+var singlePagePaths = {};
+function processPages(outputBundlePath) {
+  return __async(this, null, function* () {
+    const {
+      input: inputFolderPath,
+      output: outputFolderPath,
+      outputFormat,
+      singlePage,
+      resolveConditions
+    } = argv_default.getConfig();
+    const vcsConnector = yield getVCSConnector();
+    plugins_exports.setPlugins();
+    const navigationPaths2 = tocs_default.getNavigationPaths();
+    const concurrency = 500;
+    yield (0, import_async.mapLimit)(navigationPaths2, concurrency, (0, import_async.asyncify)((pathToFile) => __async(this, null, function* () {
+      const pathData = getPathData(pathToFile, inputFolderPath, outputFolderPath, outputFormat, outputBundlePath);
+      logger.proc(pathToFile);
+      const metaDataOptions = getMetaDataOptions(pathData, inputFolderPath.length, vcsConnector);
+      yield preparingPagesByOutputFormat(pathData, metaDataOptions, resolveConditions, singlePage);
+    })));
+    if (singlePage) {
+      yield saveSinglePages(outputBundlePath);
+    }
+  });
+}
+function getPathData(pathToFile, inputFolderPath, outputFolderPath, outputFormat, outputBundlePath) {
+  const pathToDir = (0, import_path22.dirname)(pathToFile);
+  const filename = (0, import_path22.basename)(pathToFile);
+  const fileExtension = (0, import_path22.extname)(pathToFile);
+  const fileBaseName = (0, import_path22.basename)(filename, fileExtension);
+  const outputDir = (0, import_path22.resolve)(outputFolderPath, pathToDir);
+  const outputFileName = `${fileBaseName}.${outputFormat}`;
+  const outputPath = (0, import_path22.resolve)(outputDir, outputFileName);
+  const resolvedPathToFile = (0, import_path22.resolve)(inputFolderPath, pathToFile);
+  const outputTocDir = tocs_default.getTocDir(resolvedPathToFile);
+  const pathData = {
+    pathToFile,
+    resolvedPathToFile,
+    filename,
+    fileBaseName,
+    fileExtension,
+    outputDir,
+    outputPath,
+    outputFormat,
+    outputBundlePath,
+    outputTocDir,
+    inputFolderPath,
+    outputFolderPath
+  };
+  return pathData;
+}
+function saveSinglePages(outputBundlePath) {
+  return __async(this, null, function* () {
+    const {
+      input: inputFolderPath,
+      output: outputFolderPath,
+      lang,
+      resources
+    } = argv_default.getConfig();
+    try {
+      yield Promise.all(Object.keys(singlePageResults).map((tocDir) => __async(this, null, function* () {
+        if (!singlePageResults[tocDir].length) {
+          return;
+        }
+        const singlePageBody = joinSinglePageResults(singlePageResults[tocDir], inputFolderPath, tocDir);
+        const tocPath = (0, import_path22.join)((0, import_path22.relative)(inputFolderPath, tocDir), "toc.yaml");
+        const toc = tocs_default.getForPath(tocPath) || null;
+        const preparedToc = transformTocForSinglePage(toc, {
+          root: inputFolderPath,
+          currentPath: (0, import_path22.join)(tocDir, SINGLE_PAGE_FILENAME)
+        });
+        const pageData = {
+          data: {
+            leading: false,
+            html: singlePageBody,
+            headings: [],
+            meta: resources || {},
+            toc: preparedToc
+          },
+          router: {
+            pathname: SINGLE_PAGE_FILENAME
+          },
+          lang: lang || "ru" /* RU */
+        };
+        const outputTocDir = (0, import_path22.resolve)(outputFolderPath, (0, import_path22.relative)(inputFolderPath, tocDir));
+        const relativeOutputBundlePath = (0, import_path22.relative)(outputTocDir, outputBundlePath);
+        const singlePageFn = (0, import_path22.join)(tocDir, SINGLE_PAGE_FILENAME);
+        const singlePageDataFn = (0, import_path22.join)(tocDir, SINGLE_PAGE_DATA_FILENAME);
+        const singlePageContent = generateStaticMarkup(pageData, relativeOutputBundlePath);
+        (0, import_fs10.writeFileSync)(singlePageFn, singlePageContent);
+        (0, import_fs10.writeFileSync)(singlePageDataFn, JSON.stringify(pageData));
+      })));
+    } catch (error) {
+      console.log(error);
+    }
+  });
+}
+function savePageResultForSinglePage(pageProps, pathData) {
+  const { pathToFile, outputTocDir } = pathData;
+  if (pageProps.data.leading) {
+    return;
+  }
+  singlePagePaths[outputTocDir] = singlePagePaths[outputTocDir] || /* @__PURE__ */ new Set();
+  if (singlePagePaths[outputTocDir].has(pathToFile)) {
+    return;
+  }
+  singlePagePaths[outputTocDir].add(pathToFile);
+  singlePageResults[outputTocDir] = singlePageResults[outputTocDir] || [];
+  singlePageResults[outputTocDir].push({
+    path: pathToFile,
+    content: pageProps.data.html,
+    title: pageProps.data.title
+  });
+}
+function getMetaDataOptions(pathData, inputFolderPathLength, vcsConnector) {
+  const { contributors, addSystemMeta, resources, allowCustomResources } = argv_default.getConfig();
+  const metaDataOptions = {
+    vcsConnector,
+    fileData: {
+      tmpInputFilePath: pathData.resolvedPathToFile,
+      inputFolderPathLength,
+      fileContent: ""
+    },
+    isContributorsEnabled: Boolean(contributors && vcsConnector),
+    addSystemMeta
+  };
+  if (allowCustomResources && resources) {
+    const allowedResources = Object.entries(resources).reduce((acc, [key, val]) => {
+      if (Object.keys(ResourceType).includes(key)) {
+        acc[key] = val;
+      }
+      return acc;
+    }, {});
+    metaDataOptions.resources = allowedResources;
+  }
+  return metaDataOptions;
+}
+function preparingPagesByOutputFormat(path, metaDataOptions, resolveConditions, singlePage) {
+  return __async(this, null, function* () {
+    const {
+      filename,
+      fileExtension,
+      fileBaseName,
+      outputDir,
+      resolvedPathToFile,
+      outputFormat,
+      pathToFile
+    } = path;
+    const { allowCustomResources } = argv_default.getConfig();
+    try {
+      import_shelljs6.default.mkdir("-p", outputDir);
+      const isYamlFileExtension = fileExtension === ".yaml";
+      if (resolveConditions && fileBaseName === "index" && isYamlFileExtension) {
+        leading_default.filterFile(pathToFile);
+      }
+      if (outputFormat === "md" && isYamlFileExtension && allowCustomResources) {
+        processingYamlFile(path, metaDataOptions);
+        return;
+      }
+      if (outputFormat === "md" && isYamlFileExtension || outputFormat === "html" && !isYamlFileExtension && fileExtension !== ".md") {
+        copyFileWithoutChanges(resolvedPathToFile, outputDir, filename);
+        return;
+      }
+      switch (outputFormat) {
+        case "md":
+          yield processingFileToMd(path, metaDataOptions);
+          return;
+        case "html": {
+          const resolvedFileProps = yield processingFileToHtml(path, metaDataOptions);
+          if (singlePage) {
+            savePageResultForSinglePage(resolvedFileProps, path);
+          }
+          return;
+        }
+      }
+    } catch (e) {
+      const message = `No such file or has no access to ${(0, import_chalk4.bold)(resolvedPathToFile)}`;
+      console.log(message, e);
+      import_log11.default.error(message);
+    }
+  });
+}
+function processingYamlFile(path, metaDataOptions) {
+  const { pathToFile, outputFolderPath, inputFolderPath } = path;
+  const filePath = (0, import_path22.resolve)(inputFolderPath, pathToFile);
+  const content = (0, import_fs10.readFileSync)(filePath, "utf8");
+  const parsedContent = (0, import_js_yaml7.load)(content);
+  if (metaDataOptions.resources) {
+    parsedContent.meta = __spreadValues(__spreadValues({}, parsedContent.meta), metaDataOptions.resources);
+  }
+  (0, import_fs10.writeFileSync)((0, import_path22.resolve)(outputFolderPath, pathToFile), (0, import_js_yaml7.dump)(parsedContent));
+}
+function copyFileWithoutChanges(resolvedPathToFile, outputDir, filename) {
+  const from = resolvedPathToFile;
+  const to = (0, import_path22.resolve)(outputDir, filename);
+  (0, import_fs10.copyFileSync)(from, to);
+}
+function processingFileToMd(path, metaDataOptions) {
+  return __async(this, null, function* () {
+    const { outputPath, pathToFile } = path;
+    yield resolveMd2Md({
+      inputPath: pathToFile,
+      outputPath,
+      metadata: metaDataOptions
+    });
+  });
+}
+function processingFileToHtml(path, metaDataOptions) {
+  return __async(this, null, function* () {
+    const {
+      outputBundlePath,
+      filename,
+      fileExtension,
+      outputPath,
+      pathToFile
+    } = path;
+    return resolveMd2HTML({
+      inputPath: pathToFile,
+      outputBundlePath,
+      fileExtension,
+      outputPath,
+      filename,
+      metadata: metaDataOptions
+    });
+  });
+}
+
+// src/steps/processLinter.ts
+var import_log12 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_threads = require("threads");
+var import_path23 = require("path");
+
+// src/utils/worker.ts
+function splitOnChunks(array, chunkSize = 1e3) {
+  const chunks = [];
+  for (let i = 0, j = array.length; i < j; i += chunkSize) {
+    const chunk = array.slice(i, i + chunkSize);
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+
+// src/steps/processLinter.ts
+var processLinterWorkers;
+var navigationPathsChunks;
+function processLinter() {
+  return __async(this, null, function* () {
+    const argvConfig = argv_default.getConfig();
+    const navigationPaths2 = tocs_default.getNavigationPaths();
+    if (!processLinterWorkers) {
+      lintPagesFallback(navigationPaths2);
+      return;
+    }
+    const presetStorage2 = preset_default.getPresetStorage();
+    processLinterWorkers.forEach((worker) => {
+      worker.getProcessedPages().subscribe((pathToFile) => {
+        logger.info(pathToFile, LINTING_FINISHED);
+      });
+    });
+    yield Promise.all(
+      processLinterWorkers.map((worker, i) => {
+        const navigationPathsChunk = navigationPathsChunks[i];
+        return worker.run({
+          argvConfig,
+          presetStorage: presetStorage2,
+          navigationPaths: navigationPathsChunk
+        });
+      })
+    );
+    yield Promise.all(
+      processLinterWorkers.map((worker) => {
+        return worker.finish().then((logs) => {
+          import_log12.default.add(logs);
+        });
+      })
+    );
+    yield Promise.all(
+      processLinterWorkers.map((worker) => {
+        return import_threads.Thread.terminate(worker);
+      })
+    );
+  });
+}
+function initLinterWorkers() {
+  return __async(this, null, function* () {
+    const navigationPaths2 = tocs_default.getNavigationPaths();
+    const chunkSize = getChunkSize(navigationPaths2);
+    if (process.env.DISABLE_PARALLEL_BUILD || chunkSize < MIN_CHUNK_SIZE || WORKERS_COUNT <= 0) {
+      return;
+    }
+    navigationPathsChunks = splitOnChunks(navigationPaths2, chunkSize).filter((arr) => arr.length);
+    const workersCount = navigationPathsChunks.length;
+    processLinterWorkers = yield Promise.all(new Array(workersCount).fill(null).map(() => {
+      return (0, import_threads.spawn)(new import_threads.Worker("./linter"), { timeout: 6e4 });
+    }));
+  });
+}
+function getChunkSize(arr) {
+  return Math.ceil(arr.length / WORKERS_COUNT);
+}
+function lintPagesFallback(navigationPaths2) {
+  plugins_exports.setPlugins();
+  navigationPaths2.forEach((pathToFile) => {
+    lintPage({
+      inputPath: pathToFile,
+      fileExtension: (0, import_path23.extname)(pathToFile),
+      onFinish: () => {
+        logger.info(pathToFile, LINTING_FINISHED);
+      }
+    });
+  });
+}
+
+// src/steps/processServiceFiles.ts
+var import_path24 = require("path");
+var import_walk_sync4 = __toESM(require("walk-sync"));
+var import_fs11 = require("fs");
+var import_js_yaml8 = require("js-yaml");
+var import_log13 = __toESM(require("@doc-tools/transform/lib/log"));
+var import_shelljs7 = __toESM(require("shelljs"));
+function processServiceFiles() {
+  return __async(this, null, function* () {
+    const { input: inputFolderPath, ignore = [] } = argv_default.getConfig();
+    const getFilePathsByGlobals = (globs) => {
+      return (0, import_walk_sync4.default)(inputFolderPath, {
+        directories: false,
+        includeBasePath: false,
+        globs,
+        ignore
+      });
+    };
+    preparingPresetFiles(getFilePathsByGlobals);
+    yield preparingTocFiles(getFilePathsByGlobals);
+  });
+}
+function preparingPresetFiles(getFilePathsByGlobals) {
+  const {
+    input: inputFolderPath,
+    varsPreset = "",
+    outputFormat,
+    applyPresets,
+    resolveConditions
+  } = argv_default.getConfig();
+  try {
+    const presetsFilePaths = getFilePathsByGlobals(["**/presets.yaml"]);
+    for (const path of presetsFilePaths) {
+      logger.proc(path);
+      const pathToPresetFile = (0, import_path24.resolve)(inputFolderPath, path);
+      const content = (0, import_fs11.readFileSync)(pathToPresetFile, "utf8");
+      const parsedPreset = (0, import_js_yaml8.load)(content);
+      preset_default.add(parsedPreset, path, varsPreset);
+      if (outputFormat === "md" && (!applyPresets || !resolveConditions)) {
+        saveFilteredPresets(path, parsedPreset);
+      }
+    }
+  } catch (error) {
+    import_log13.default.error(`Preparing presets.yaml files failed. Error: ${error}`);
+    throw error;
+  }
+}
+function saveFilteredPresets(path, parsedPreset) {
+  const { output: outputFolderPath, varsPreset = "" } = argv_default.getConfig();
+  const outputPath = (0, import_path24.resolve)(outputFolderPath, path);
+  const filteredPreset = {
+    default: parsedPreset.default
+  };
+  if (parsedPreset[varsPreset]) {
+    filteredPreset[varsPreset] = parsedPreset[varsPreset];
+  }
+  const outputPreset = (0, import_js_yaml8.dump)(filteredPreset, {
+    lineWidth: 120
+  });
+  import_shelljs7.default.mkdir("-p", (0, import_path24.dirname)(outputPath));
+  (0, import_fs11.writeFileSync)(outputPath, outputPreset);
+}
+function preparingTocFiles(getFilePathsByGlobals) {
+  return __async(this, null, function* () {
+    try {
+      const tocFilePaths = getFilePathsByGlobals(["**/toc.yaml"]);
+      for (const path of tocFilePaths) {
+        logger.proc(path);
+        yield tocs_default.add(path);
+      }
+    } catch (error) {
+      import_log13.default.error(`Preparing toc.yaml files failed. Error: ${error}`);
+      throw error;
+    }
+  });
+}
+
+// src/steps/processMapFile.ts
+var import_fs12 = require("fs");
+var import_path25 = require("path");
+function prepareMapFile() {
+  const {
+    output: outputFolderPath
+  } = argv_default.getConfig();
+  const navigationPathsWithoutExtensions = tocs_default.getNavigationPaths().map((path) => {
+    let preparedPath = convertBackSlashToSlash(path.replace((0, import_path25.extname)(path), ""));
+    if (preparedPath.endsWith("/index")) {
+      preparedPath = preparedPath.substring(0, preparedPath.length - 5);
+    }
+    return preparedPath;
+  });
+  const navigationPaths2 = { files: [...new Set(navigationPathsWithoutExtensions)] };
+  const filesMapBuffer = Buffer.from(JSON.stringify(navigationPaths2, null, "	"), "utf8");
+  const mapFile = (0, import_path25.join)(outputFolderPath, "files.json");
+  (0, import_fs12.writeFileSync)(mapFile, filesMapBuffer);
+}
+
+// src/cmd/build/index.ts
+var import_shelljs8 = __toESM(require("shelljs"));
+
+// src/cmd/publish/upload.ts
+var import_fs13 = require("fs");
+var import_walk_sync5 = __toESM(require("walk-sync"));
+var import_path26 = require("path");
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_mime_types = __toESM(require("mime-types"));
+var import_async2 = require("async");
+function upload(props) {
+  return __async(this, null, function* () {
+    const {
+      input,
+      ignore = [],
+      endpoint,
+      region,
+      bucket,
+      prefix,
+      accessKeyId,
+      secretAccessKey
+    } = props;
+    const s3Client = new import_client_s3.S3Client({
+      endpoint,
+      region,
+      credentials: { accessKeyId, secretAccessKey }
+    });
+    const filesToPublish = (0, import_walk_sync5.default)((0, import_path26.resolve)(input), {
+      directories: false,
+      includeBasePath: false,
+      ignore
+    });
+    yield (0, import_async2.mapLimit)(filesToPublish, 100, (0, import_async2.asyncify)((pathToFile) => __async(this, null, function* () {
+      const mimeType = import_mime_types.default.lookup(pathToFile);
+      logger.upload(pathToFile);
+      try {
+        yield s3Client.send(new import_client_s3.PutObjectCommand({
+          ContentType: mimeType ? mimeType : void 0,
+          Bucket: bucket,
+          Key: convertBackSlashToSlash((0, import_path26.join)(prefix, pathToFile)),
+          Body: (0, import_fs13.createReadStream)((0, import_path26.resolve)(input, pathToFile))
+        }));
+      } catch (error) {
+        logger.error(pathToFile, error.message);
+      }
+    })));
+  });
+}
+
+// src/cmd/build/index.ts
+var import_glob3 = __toESM(require("glob"));
+var build = {
+  command: ["build", "$0"],
+  description: "Build documentation in target directory",
+  handler,
+  builder
+};
+function builder(argv) {
+  return argv.option("input", {
+    alias: "i",
+    describe: "Path to input folder with .md files",
+    type: "string",
+    group: "Build options:"
+  }).option("output", {
+    alias: "o",
+    describe: "Path to output folder",
+    type: "string",
+    group: "Build options:"
+  }).option("varsPreset", {
+    default: "default",
+    describe: "Target vars preset of documentation <external|internal>",
+    group: "Build options:"
+  }).option("output-format", {
+    default: "html",
+    describe: "Format of output file <html|md>",
+    group: "Build options:"
+  }).option("vars", {
+    alias: "v",
+    default: "{}",
+    describe: "List of markdown variables",
+    group: "Build options:"
+  }).option("apply-presets", {
+    default: true,
+    describe: "Should apply presets. Only for --output-format=md",
+    type: "boolean",
+    group: "Build options:"
+  }).option("resolve-conditions", {
+    default: true,
+    describe: "Should resolve conditions. Only for --output-format=md",
+    type: "boolean",
+    group: "Build options:"
+  }).option("conditions-in-code", {
+    default: false,
+    describe: "Meet conditions in code blocks",
+    type: "boolean",
+    group: "Build options:"
+  }).option("disable-liquid", {
+    default: false,
+    describe: "Disable template engine",
+    type: "boolean",
+    group: "Build options:"
+  }).option("allowHTML", {
+    default: false,
+    describe: "Allow to use HTML in Markdown files",
+    type: "boolean",
+    group: "Build options:"
+  }).option("ignore-stage", {
+    default: "skip" /* SKIP */,
+    describe: "Ignore tocs with stage",
+    group: "Build options:"
+  }).option("ignore-author-patterns", {
+    default: [],
+    describe: "Ignore authors if they contain passed string",
+    group: "Build options:",
+    type: "array"
+  }).option("contributors", {
+    default: false,
+    describe: "Should attach contributors into files",
+    type: "boolean",
+    group: "Build options:"
+  }).option("add-system-meta", {
+    default: false,
+    describe: "Should add system section variables form presets into files meta data",
+    type: "boolean",
+    group: "Build options:"
+  }).option("add-map-file", {
+    default: false,
+    describe: "Should add all paths of documentation into file.json",
+    type: "boolean",
+    group: "Build options:"
+  }).option("single-page", {
+    default: false,
+    describe: "Beta functionality: Build a single page in the output folder also",
+    type: "boolean",
+    group: "Build options:"
+  }).option("publish", {
+    default: false,
+    describe: "Should upload output files to S3 storage",
+    type: "boolean",
+    group: "Build options:"
+  }).option("remove-hidden-toc-items", {
+    default: false,
+    describe: "Remove hidden toc items",
+    type: "boolean",
+    group: "Build options:"
+  }).option("lint-disabled", {
+    default: false,
+    describe: "Disable linting",
+    type: "boolean",
+    group: "Build options:"
+  }).option("build-disabled", {
+    default: false,
+    describe: "Disable building",
+    type: "boolean",
+    group: "Build options:"
+  }).option("allow-custom-resources", {
+    default: false,
+    describe: "Allow loading custom resources",
+    type: "boolean",
+    group: "Build options:"
+  }).option("static-content", {
+    default: false,
+    describe: "Include static content in the page",
+    type: "boolean",
+    group: "Build options:"
+  }).check(argvValidator).example("yfm -i ./input -o ./output", "").demandOption(["input", "output"], "Please provide input and output arguments to work with this tool");
+}
+function handler(args) {
+  return __async(this, null, function* () {
+    var _a;
+    const userOutputFolder = (0, import_path27.resolve)(args.output);
+    const tmpInputFolder = (0, import_path27.resolve)(args.output, TMP_INPUT_FOLDER);
+    const tmpOutputFolder = (0, import_path27.resolve)(args.output, TMP_OUTPUT_FOLDER);
+    try {
+      argv_default.init(__spreadProps(__spreadValues({}, args), {
+        rootInput: args.input,
+        input: tmpInputFolder,
+        output: tmpOutputFolder
+      }));
+      includers_exports.init([import_includer.default]);
+      const {
+        output: outputFolderPath,
+        outputFormat,
+        publish: publish2,
+        lintDisabled,
+        buildDisabled,
+        addMapFile,
+        allowCustomResources,
+        resources
+      } = argv_default.getConfig();
+      preparingTemporaryFolders(userOutputFolder);
+      yield processServiceFiles();
+      processExcludedFiles();
+      if (addMapFile) {
+        prepareMapFile();
+      }
+      const outputBundlePath = (0, import_path27.join)(outputFolderPath, BUNDLE_FOLDER);
+      const pathToConfig = args.config || (0, import_path27.join)(args.input, YFM_CONFIG_FILENAME);
+      const pathToRedirects = (0, import_path27.join)(args.input, REDIRECTS_FILENAME);
+      const pathToLintConfig = (0, import_path27.join)(args.input, LINT_CONFIG_FILENAME);
+      if (!lintDisabled) {
+        yield initLinterWorkers();
+      }
+      const processes = [
+        !lintDisabled && processLinter(),
+        !buildDisabled && processPages(outputBundlePath)
+      ].filter(Boolean);
+      yield Promise.all(processes);
+      if (!buildDisabled) {
+        switch (outputFormat) {
+          case "html":
+            processAssets(outputBundlePath);
+            break;
+          case "md": {
+            import_shelljs8.default.cp((0, import_path27.resolve)(pathToConfig), tmpOutputFolder);
+            import_shelljs8.default.cp((0, import_path27.resolve)(pathToRedirects), tmpOutputFolder);
+            import_shelljs8.default.cp((0, import_path27.resolve)(pathToLintConfig), tmpOutputFolder);
+            if (resources && allowCustomResources) {
+              const resourcePaths = [];
+              Object.keys(resources).forEach((type) => {
+                var _a2;
+                return (_a2 = resources[type]) == null ? void 0 : _a2.forEach((path) => resourcePaths.push(path));
+              });
+              copyFiles(args.input, tmpOutputFolder, resourcePaths);
+            }
+            break;
+          }
+        }
+        import_shelljs8.default.cp("-r", [(0, import_path27.join)(tmpOutputFolder, "*"), (0, import_path27.join)(tmpOutputFolder, ".*")], userOutputFolder);
+        if (publish2) {
+          const DEFAULT_PREFIX = (_a = process.env.YFM_STORAGE_PREFIX) != null ? _a : "";
+          const {
+            ignore = [],
+            storageRegion,
+            storageEndpoint: endpoint,
+            storageBucket: bucket,
+            storagePrefix: prefix = DEFAULT_PREFIX,
+            storageKeyId: accessKeyId,
+            storageSecretKey: secretAccessKey
+          } = argv_default.getConfig();
+          yield upload({
+            input: userOutputFolder,
+            region: storageRegion,
+            ignore,
+            endpoint,
+            bucket,
+            prefix,
+            accessKeyId,
+            secretAccessKey
+          });
+        }
+      }
+    } catch (err) {
+      logger.error("", err.message);
+    } finally {
+      processLogs(tmpInputFolder);
+      import_shelljs8.default.rm("-rf", tmpInputFolder, tmpOutputFolder);
+    }
+  });
+}
+function preparingTemporaryFolders(userOutputFolder) {
+  const args = argv_default.getConfig();
+  import_shelljs8.default.mkdir("-p", userOutputFolder);
+  import_shelljs8.default.rm("-rf", args.input, args.output);
+  import_shelljs8.default.mkdir(args.input, args.output);
+  import_shelljs8.default.chmod("-R", "u+w", args.input);
+  copyFiles(args.rootInput, args.input, import_glob3.default.sync("**", {
+    cwd: args.rootInput,
+    nodir: true,
+    follow: true,
+    ignore: [
+      "node_modules/**",
+      "*/node_modules/**"
+    ]
+  }));
+}
+
+// src/cmd/publish/index.ts
+var import_path28 = require("path");
+var command = "publish";
+var description = "Upload builded documentation to target S3 bucket";
+var publish = {
+  command,
+  description,
+  handler: handler2,
+  builder: builder2
+};
+function builder2(argv) {
+  return argv.option("strict", {
+    default: true
+  }).option("input", {
+    alias: "i",
+    describe: "Path to folder with builded files",
+    type: "string",
+    required: true,
+    group: "Upload options"
+  }).option("endpoint", {
+    describe: "S3 bucket endpoint",
+    default: "https://s3.amazonaws.com",
+    type: "string",
+    group: "Upload options"
+  }).option("region", {
+    describe: "S3 bucket region",
+    default: "eu-central-1",
+    type: "string",
+    group: "Upload options"
+  }).option("bucket", {
+    describe: "S3 bucket name",
+    type: "string",
+    required: true,
+    group: "Upload options"
+  }).option("prefix", {
+    describe: "S3 bucket ",
+    default: "",
+    type: "string",
+    group: "Upload options"
+  }).option("access-key-id", {
+    describe: "S3 bucket AccessKeyId",
+    type: "string",
+    required: true,
+    group: "Upload options"
+  }).option("secret-access-key", {
+    describe: "S3 bucket SecretAccessKey",
+    type: "string",
+    required: true,
+    group: "Upload options"
+  });
+}
+function handler2(args) {
+  return __async(this, null, function* () {
+    argv_default.init(__spreadValues({}, args));
+    const {
+      input,
+      endpoint,
+      bucket,
+      prefix
+    } = argv_default.getConfig();
+    logger.info("", `Upload artifacts from ${input} to ${(0, import_path28.join)(endpoint, bucket, prefix)}`);
+    try {
+      yield upload(argv_default.getConfig());
+    } catch (error) {
+      logger.error("", error.message);
+    }
+  });
+}
+
+// src/cmd/xliff/extract.ts
+var import_path29 = require("path");
+var import_markdown_translation = __toESM(require("@diplodoc/markdown-translation"));
+var import_async3 = require("async");
+var { promises: { readFile: readFile3, writeFile: writeFile2, mkdir: mkdir2 } } = require("fs");
+var command2 = "extract";
+var description2 = "extract xliff and skeleton from yfm documentation";
+var extract2 = { command: command2, description: description2, handler: handler3, builder: builder3 };
+var MD_GLOB2 = "**/*.md";
+var MAX_CONCURRENCY = 50;
+var ExtractError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+  }
+};
+var USAGE = `yfm xliff extract --input <folder-with-markdown> --output <folder-to-store-xlff-and-skeleton> --sll <source-language>-<source-locale> --tll <target-language>-<target-locale>
+
+where <source/target-language> is the language code, as described in ISO 639-1.
+
+where <source/target-locale> is the locale code in alpha-2 format, as described in ISO 3166-1`;
+function builder3(argv) {
+  return argv.option("source-language-locale", {
+    alias: "sll",
+    describe: "source language and locale",
+    type: "string"
+  }).option("target-language-locale", {
+    alias: "tll",
+    describe: "target language and locale",
+    type: "string"
+  }).option("input", {
+    alias: "i",
+    describe: "input folder with markdown files",
+    type: "string"
+  }).option("output", {
+    alias: "o",
+    describe: "output folder to store xliff and skeleton files",
+    type: "string"
+  }).demandOption(["source-language-locale", "target-language-locale", "input", "output"], USAGE);
+}
+function handler3(args) {
+  return __async(this, null, function* () {
+    argv_default.init(__spreadValues({}, args));
+    const { input, output, sourceLanguageLocale, targetLanguageLocale } = args;
+    let source;
+    let target;
+    try {
+      source = parseLanguageLocale(sourceLanguageLocale);
+      target = parseLanguageLocale(targetLanguageLocale);
+    } catch (err) {
+      if (err instanceof Error) {
+        logger.error(input, err.message);
+      }
+    }
+    let cache = {};
+    let found = [];
+    try {
+      ({ state: { found, cache } } = yield glob((0, import_path29.join)(input, MD_GLOB2), {
+        nosort: true,
+        cache
+      }));
+    } catch (err) {
+      if (err instanceof Error) {
+        logger.error(input, err.message);
+      }
+    }
+    const pipelineParameters = { source, target, input, output };
+    const configuredPipeline = pipeline2(pipelineParameters);
+    try {
+      logger.info(input, "starting xliff and skeleton generation pipeline");
+      yield (0, import_async3.eachLimit)(found, MAX_CONCURRENCY, (0, import_async3.asyncify)(configuredPipeline));
+      logger.info(input, "finished xliff and skeleton generation pipeline");
+    } catch (err) {
+      if (err instanceof Error || err instanceof ExtractError) {
+        const file = err instanceof ExtractError ? err.path : input;
+        logger.error(file, err.message);
+      }
+    }
+  });
+}
+function parseLanguageLocale(languageLocale) {
+  const [language, locale] = languageLocale.split("-");
+  if ((language == null ? void 0 : language.length) && (locale == null ? void 0 : locale.length)) {
+    return { language, locale };
+  }
+  throw new Error("invalid language-locale string");
+}
+function pipeline2(params) {
+  const { input, output, source, target } = params;
+  return (markdownPath) => __async(this, null, function* () {
+    const markdown = yield reader({ path: markdownPath });
+    const extension = (0, import_path29.extname)(markdownPath);
+    const outputRelativePath = markdownPath.replace(extension, "").slice(input.length);
+    const outputPath = (0, import_path29.join)(output, outputRelativePath);
+    const xlfPath = outputPath + ".xliff";
+    const skeletonPath = outputPath + ".skl.md";
+    const extractParameters = {
+      markdownPath,
+      skeletonPath,
+      markdown,
+      source,
+      target
+    };
+    const extracted = yield extractor(extractParameters);
+    const writerParameters = __spreadProps(__spreadValues({}, extracted), {
+      xlfPath,
+      skeletonPath
+    });
+    yield writer(writerParameters);
+  });
+}
+function reader(params) {
+  return __async(this, null, function* () {
+    const { path } = params;
+    let markdown;
+    try {
+      logger.info(path, "reading markdown file");
+      markdown = yield readFile3(path, { encoding: "utf-8" });
+      logger.info(path, "finished reading markdown file");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ExtractError(err.message, path);
+      }
+    }
+    return markdown;
+  });
+}
+function extractor(params) {
+  return __async(this, null, function* () {
+    let extracted;
+    logger.info(params.markdownPath, "generating skeleton and xliff from markdown");
+    try {
+      extracted = import_markdown_translation.default.extract(params);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ExtractError(err.message, params.markdownPath);
+      }
+    }
+    logger.info(params.markdownPath, "finished generating skeleton and xliff from markdown");
+    return extracted;
+  });
+}
+function writer(params) {
+  return __async(this, null, function* () {
+    const { xlfPath, skeletonPath, xlf, skeleton } = params;
+    logger.info(params.xlfPath, "writing xliff file");
+    logger.info(params.skeletonPath, "writing skeleton file");
+    yield mkdir2((0, import_path29.dirname)(xlfPath), { recursive: true });
+    yield Promise.all([writeFile2(skeletonPath, skeleton), writeFile2(xlfPath, xlf)]);
+    logger.info(params.xlfPath, "finished writing xliff file");
+    logger.info(params.skeletonPath, "finished writing skeleton file");
+  });
+}
+
+// src/cmd/xliff/compose.ts
+var import_path30 = require("path");
+var import_markdown_translation2 = __toESM(require("@diplodoc/markdown-translation"));
+var import_async4 = require("async");
+var { promises: { readFile: readFile4, writeFile: writeFile3, mkdir: mkdir3 } } = require("fs");
+var command3 = "compose";
+var description3 = "compose xliff and skeleton into documentation";
+var compose = { command: command3, description: description3, handler: handler4, builder: builder4 };
+var SKL_MD_GLOB = "**/*.skl.md";
+var XLF_GLOB = "**/*.xliff";
+var MAX_CONCURRENCY2 = 50;
+var ComposeError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+  }
+};
+var USAGE2 = "yfm xliff compose --input <folder-with-xliff-and-skeleton> --ouput <folder-to-store-translated-markdown>";
+function builder4(argv) {
+  return argv.option("input", {
+    alias: "i",
+    describe: "input folder with xliff and skeleton files",
+    type: "string"
+  }).option("output", {
+    alias: "o",
+    describe: "output folder where translated markdown will be stored",
+    type: "string"
+  }).demandOption(["input", "output"], USAGE2);
+}
+function handler4(args) {
+  return __async(this, null, function* () {
+    argv_default.init(__spreadValues({}, args));
+    const { input, output } = args;
+    let cache = {};
+    let skeletonPaths = [];
+    let xliffPaths = [];
+    try {
+      ({ state: { found: skeletonPaths, cache } } = yield glob((0, import_path30.join)(input, SKL_MD_GLOB), {
+        nosort: false,
+        cache
+      }));
+      ({ state: { found: xliffPaths, cache } } = yield glob((0, import_path30.join)(input, XLF_GLOB), {
+        nosort: false,
+        cache
+      }));
+      if (xliffPaths.length !== skeletonPaths.length) {
+        throw new ComposeError("number of xliff and skeleton files does'not match", input);
+      }
+    } catch (err) {
+      if (err instanceof Error || err instanceof ComposeError) {
+        const file = err instanceof ComposeError ? err.path : input;
+        logger.error(file, err.message);
+      }
+    }
+    const pipelineParameters = { input, output };
+    const configuredPipeline = pipeline3(pipelineParameters);
+    try {
+      logger.info(input, "staring translated markdown composition pipeline");
+      yield (0, import_async4.eachLimit)(xliffPaths, MAX_CONCURRENCY2, configuredPipeline);
+      logger.info(input, "finished translated markdown composition pipeline");
+    } catch (err) {
+      if (err instanceof Error || err instanceof ComposeError) {
+        const file = err instanceof ComposeError ? err.path : input;
+        logger.error(file, err.message);
+      }
+    }
+  });
+}
+function pipeline3(params) {
+  const { input, output } = params;
+  return (xliffPath) => __async(this, null, function* () {
+    const extension = (0, import_path30.extname)(xliffPath);
+    const extensionLessPath = xliffPath.replace(extension, "");
+    const skeletonPath = extensionLessPath + ".skl.md";
+    const readerParameters = { xliffPath, skeletonPath };
+    const read = yield reader2(readerParameters);
+    const composerParameters = __spreadProps(__spreadValues({}, read), {
+      skeletonPath,
+      xliffPath
+    });
+    const { markdown } = yield composer(composerParameters);
+    const inputRelativePath = extensionLessPath.slice(input.length);
+    const markdownPath = (0, import_path30.join)(output, inputRelativePath) + ".md";
+    const writerParameters = {
+      markdown,
+      markdownPath
+    };
+    yield writer2(writerParameters);
+  });
+}
+function reader2(params) {
+  return __async(this, null, function* () {
+    const { skeletonPath, xliffPath } = params;
+    let skeleton;
+    let xlf;
+    try {
+      logger.info(skeletonPath, "reading skeleton file");
+      skeleton = yield readFile4(skeletonPath, { encoding: "utf-8" });
+      logger.info(skeletonPath, "finished reading skeleton file");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ComposeError(err.message, skeletonPath);
+      }
+    }
+    try {
+      logger.info(xliffPath, "reading xliff file");
+      xlf = yield readFile4(xliffPath, { encoding: "utf-8" });
+      logger.info(xliffPath, "finished reading xliff file");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ComposeError(err.message, xliffPath);
+      }
+    }
+    return { skeleton, xlf };
+  });
+}
+function composer(params) {
+  return __async(this, null, function* () {
+    const { skeletonPath, xliffPath } = params;
+    let markdown;
+    try {
+      logger.info(skeletonPath, "composing markdown from xliff and skeleton");
+      logger.info(xliffPath, "composing markdown from xliff and skeleton");
+      markdown = import_markdown_translation2.default.compose(params);
+      logger.info(skeletonPath, "finished composing markdown from xliff and skeleton");
+      logger.info(xliffPath, "finished composing markdown from xliff and skeleton");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ComposeError(err.message, `${xliffPath} ${skeletonPath}`);
+      }
+    }
+    return { markdown };
+  });
+}
+function writer2(params) {
+  return __async(this, null, function* () {
+    const { markdown, markdownPath } = params;
+    try {
+      logger.info(markdownPath, "writing markdown file");
+      yield mkdir3((0, import_path30.dirname)(markdownPath), { recursive: true });
+      yield writeFile3(markdownPath, markdown);
+      logger.info(markdownPath, "finished writing markdown file");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new ComposeError(err.message, markdownPath);
+      }
+    }
+  });
+}
+
+// src/cmd/xliff/index.ts
+var command4 = "xliff";
+var description4 = "extract xliff and skeleton from documentation files\ncompose xliff and skeleton into documentation";
+var xliff = {
+  command: command4,
+  description: description4,
+  handler: () => {
+  },
+  builder: builder5
+};
+function builder5(argv) {
+  return argv.command(extract2).command(compose).demandCommand(1, `provide one of the folowing ${command4} commands: ${extract2.command}, ${compose.command}`);
+}
+
+// src/cmd/translate/index.ts
+var import_async5 = require("async");
+var import_path32 = require("path");
+var import_promises4 = require("fs/promises");
+var import_fast_xml_parser = require("fast-xml-parser");
+var import_session = require("@yandex-cloud/nodejs-sdk/dist/session");
+var import_service_clients = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/service_clients");
+var import_translation_service = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/ai/translate/v2/translation_service");
+
+// src/packages/credentials/yandex-oauth.ts
+var import_promises3 = require("fs/promises");
+var import_process3 = require("process");
+var import_os = require("os");
+var import_path31 = require("path");
+var YANDEX_OAUTH_TOKEN_FILENAME = ".ya_oauth_token";
+function getYandexOAuthToken() {
+  return __async(this, null, function* () {
+    const { YANDEX_OAUTH_TOKEN } = import_process3.env;
+    return YANDEX_OAUTH_TOKEN != null ? YANDEX_OAUTH_TOKEN : getYandexOAuthTokenFromHomeDir();
+  });
+}
+function getYandexOAuthTokenFromHomeDir() {
+  return __async(this, null, function* () {
+    const error = "failed reading yandex oauth token";
+    const path = (0, import_path31.join)((0, import_os.homedir)(), YANDEX_OAUTH_TOKEN_FILENAME);
+    let token;
+    try {
+      token = yield (0, import_promises3.readFile)(path, { encoding: "utf8" });
+      token = token.trim();
+      if (!(token == null ? void 0 : token.length)) {
+        throw new Error(error);
+      }
+    } catch (err) {
+      logger.error(error);
+      throw err;
+    }
+    return token;
+  });
+}
+
+// src/cmd/translate/index.ts
+var yfm2xliff = require("@doc-tools/yfm2xliff/lib/cjs");
+var composer2 = (xliff2, skeleton) => __async(void 0, null, function* () {
+  return new Promise((res, rej) => yfm2xliff.compose(xliff2, skeleton, (err, composed) => {
+    if (err) {
+      rej(err);
+    }
+    return res(composed);
+  }));
+});
+var command5 = "translate";
+var description5 = "translate documentation with Yandex.Cloud Translator API";
+var translate = {
+  command: command5,
+  description: description5,
+  handler: handler5,
+  builder: builder6
+};
+var MD_GLOB3 = "**/*.md";
+var REQUESTS_LIMIT = 20;
+var RETRY_LIMIT = 8;
+var MTRANS_LOCALE = "MTRANS";
+function builder6(argv) {
+  return argv.option("source-language", {
+    alias: "sl",
+    describe: "source language code",
+    type: "string"
+  }).option("target-language", {
+    alias: "tl",
+    describe: "target language code",
+    type: "string"
+  }).demandOption(
+    ["source-language", "target-language"],
+    "command requires to specify source and target languages"
+  );
+}
+var TranslatorError = class extends Error {
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+  }
+};
+function handler5(args) {
+  return __async(this, null, function* () {
+    argv_default.init(__spreadValues({}, args));
+    const {
+      input,
+      output,
+      yandexCloudTranslateFolderId,
+      yandexCloudTranslateGlossaryPairs,
+      sl: sourceLanguage,
+      tl: targetLanguage
+    } = args;
+    logger.info(input, `translating documentation from ${sourceLanguage} to ${targetLanguage} language`);
+    try {
+      let found = [];
+      ({ state: { found } } = yield glob((0, import_path32.join)(input, MD_GLOB3), {
+        nosort: true
+      }));
+      const oauthToken = yield getYandexOAuthToken();
+      const translatorParams = {
+        input,
+        output,
+        sourceLanguage,
+        targetLanguage,
+        yandexCloudTranslateGlossaryPairs,
+        folderId: yandexCloudTranslateFolderId,
+        oauthToken
+      };
+      const translateFn = translator(translatorParams);
+      yield (0, import_async5.eachLimit)(found, REQUESTS_LIMIT, (0, import_async5.asyncify)(translateFn));
+    } catch (err) {
+      if (err instanceof Error || err instanceof TranslatorError) {
+        const message = err.message;
+        const file = err instanceof TranslatorError ? err.path : "";
+        logger.error(file, message);
+      }
+    }
+    logger.info(output, `translated documentation from ${sourceLanguage} to ${targetLanguage} language`);
+  });
+}
+function translator(params) {
+  const {
+    oauthToken,
+    folderId,
+    input,
+    output,
+    sourceLanguage,
+    targetLanguage,
+    yandexCloudTranslateGlossaryPairs
+  } = params;
+  const session = new import_session.Session({ oauthToken });
+  const client3 = session.client(import_service_clients.TranslationServiceClient);
+  return (mdPath) => __async(this, null, function* () {
+    try {
+      logger.info(mdPath, "translating");
+      const md = yield (0, import_promises4.readFile)((0, import_path32.resolve)(mdPath), { encoding: "utf-8" });
+      const extracted = yield yfm2xliff.extract({
+        md,
+        mdPath,
+        source: sourceLanguage,
+        target: targetLanguage,
+        sklPath: "",
+        xlfPath: ""
+      });
+      const texts = parseSourcesFromXLIFF(extracted.xliff);
+      const machineTranslateParams = import_translation_service.TranslateRequest.fromPartial({
+        texts,
+        folderId,
+        sourceLanguageCode: sourceLanguage,
+        targetLanguageCode: targetLanguage,
+        glossaryConfig: {
+          glossaryData: {
+            glossaryPairs: yandexCloudTranslateGlossaryPairs
+          }
+        },
+        format: import_translation_service.TranslateRequest_Format.PLAIN_TEXT
+      });
+      const translations = yield (0, import_async5.retry)({ times: RETRY_LIMIT, interval: (count) => {
+        return (1 << count) * 1e3;
+      } }, (0, import_async5.asyncify)(
+        () => __async(this, null, function* () {
+          return yield client3.translate(machineTranslateParams).then((results) => results.translations.map(({ text }) => text));
+        })
+      ));
+      const createXLIFFDocumentParams = {
+        sourceLanguage: sourceLanguage + "-" + MTRANS_LOCALE,
+        targetLanguage: targetLanguage + "-" + MTRANS_LOCALE,
+        sources: texts,
+        targets: translations
+      };
+      const translatedXLIFF = createXLIFFDocument(createXLIFFDocumentParams);
+      const composed = yield composer2(translatedXLIFF, extracted.skeleton);
+      const outputPath = mdPath.replace(input, output);
+      yield (0, import_promises4.mkdir)((0, import_path32.dirname)(outputPath), { recursive: true });
+      yield (0, import_promises4.writeFile)(outputPath, composed);
+      logger.info(outputPath, "finished translating");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new TranslatorError(err.toString(), mdPath);
+      }
+    }
+  });
+}
+function parseSourcesFromXLIFF(xliff2) {
+  var _a, _b, _c, _d;
+  const parser = new import_fast_xml_parser.XMLParser();
+  const inputs = (_d = (_c = (_b = (_a = parser.parse(xliff2)) == null ? void 0 : _a.xliff) == null ? void 0 : _b.file) == null ? void 0 : _c.body["trans-unit"]) != null ? _d : [];
+  return Array.isArray(inputs) ? inputs.map(({ source }) => source) : [inputs.source];
+}
+function createXLIFFDocument(params) {
+  const { sourceLanguage, targetLanguage, sources, targets } = params;
+  const unit = (text, i) => `
+<trans-unit id="${i + 1}">
+    <source xml:lang="${sourceLanguage}">${sources[i]}</source>
+    <target xml:lang="${targetLanguage}">${text}</target>
+</trans-unit>`;
+  const doc = `
+<?xml version="1.0" encoding="UTF-8"?>
+<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" version="1.2">
+    <file original="" source-language="${sourceLanguage}" target-language="${targetLanguage}">
+        <header>
+            <skl><external-file href="" /></skl>
+        </header>
+        <body>${targets.map(unit)}</body>
+    </file>
+</xliff>`;
+  return doc;
+}
+
+// src/index.ts
+console.time(MAIN_TIMER_ID);
+import_yargs.default.command(build).command(publish).command(xliff).command(translate).option("config", {
+  alias: "c",
+  describe: "YFM configuration file",
+  type: "string"
+}).option("strict", {
+  alias: "s",
+  default: false,
+  describe: "Run in strict mode",
+  type: "boolean"
+}).option("quiet", {
+  alias: "q",
+  default: false,
+  describe: "Run in quiet mode. Don't write logs to stdout",
+  type: "boolean"
+}).group(["config", "strict", "quiet", "help", "version"], "Common options:").version(true ? "4.0.0" : "").help().parse((0, import_helpers.hideBin)(process.argv), {}, (err, { strict }, output) => {
+  console.timeEnd(MAIN_TIMER_ID);
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  const { warn, error } = import_log14.default.get();
+  if (strict && warn.length || error.length) {
+    process.exit(1);
+  }
+  console.log(output);
+  process.exit(0);
+});
+//# sourceMappingURL=index.js.map