docs-i18n 0.1.0

package/dist/chunk-3YNFMSJH.js

@@ -0,0 +1,30 @@
+// src/config.ts
+async function loadConfig(path) {
+  const configPath = path ?? "docs-i18n.config.ts";
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      `${process.cwd()}/${configPath}`
+    );
+    return mod.default ?? mod;
+  } catch {
+    throw new Error(`Cannot load config from ${configPath}. Create a docs-i18n.config.ts file.`);
+  }
+}
+function flattenSources(config) {
+  const projects = Object.entries(config.projects);
+  const singleProject = projects.length === 1;
+  return projects.flatMap(
+    ([projectId, project]) => Object.entries(project.sources).map(([version, sourcePath]) => ({
+      project: projectId,
+      version,
+      sourcePath,
+      versionKey: singleProject ? version : `${projectId}/${version}`
+    }))
+  );
+}
+
+export {
+  loadConfig,
+  flattenSources
+};

package/dist/chunk-55MBYBVK.js

@@ -0,0 +1,368 @@
+import {
+  __commonJSMin
+} from "./chunk-PTIH4GGE.js";
+
+// node_modules/vite/dist/node/chunks/lib.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  var openParentheses = "(".charCodeAt(0);
+  var closeParentheses = ")".charCodeAt(0);
+  var singleQuote = "'".charCodeAt(0);
+  var doubleQuote = '"'.charCodeAt(0);
+  var backslash = "\\".charCodeAt(0);
+  var slash = "/".charCodeAt(0);
+  var comma = ",".charCodeAt(0);
+  var colon = ":".charCodeAt(0);
+  var star = "*".charCodeAt(0);
+  var uLower = "u".charCodeAt(0);
+  var uUpper = "U".charCodeAt(0);
+  var plus = "+".charCodeAt(0);
+  var isUnicodeRange = /^[a-f0-9?-]+$/i;
+  module.exports = function(input) {
+    var tokens = [];
+    var value = input;
+    var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
+    var pos = 0;
+    var code = value.charCodeAt(pos);
+    var max = value.length;
+    var stack = [{ nodes: tokens }];
+    var balanced = 0;
+    var parent;
+    var name = "";
+    var before = "";
+    var after = "";
+    while (pos < max) if (code <= 32) {
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      token = value.slice(pos, next);
+      prev = tokens[tokens.length - 1];
+      if (code === closeParentheses && balanced) after = token;
+      else if (prev && prev.type === "div") {
+        prev.after = token;
+        prev.sourceEndIndex += token.length;
+      } else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) before = token;
+      else tokens.push({
+        type: "space",
+        sourceIndex: pos,
+        sourceEndIndex: next,
+        value: token
+      });
+      pos = next;
+    } else if (code === singleQuote || code === doubleQuote) {
+      next = pos;
+      quote = code === singleQuote ? "'" : '"';
+      token = {
+        type: "string",
+        sourceIndex: pos,
+        quote
+      };
+      do {
+        escape = false;
+        next = value.indexOf(quote, next + 1);
+        if (~next) {
+          escapePos = next;
+          while (value.charCodeAt(escapePos - 1) === backslash) {
+            escapePos -= 1;
+            escape = !escape;
+          }
+        } else {
+          value += quote;
+          next = value.length - 1;
+          token.unclosed = true;
+        }
+      } while (escape);
+      token.value = value.slice(pos + 1, next);
+      token.sourceEndIndex = token.unclosed ? next : next + 1;
+      tokens.push(token);
+      pos = next + 1;
+      code = value.charCodeAt(pos);
+    } else if (code === slash && value.charCodeAt(pos + 1) === star) {
+      next = value.indexOf("*/", pos);
+      token = {
+        type: "comment",
+        sourceIndex: pos,
+        sourceEndIndex: next + 2
+      };
+      if (next === -1) {
+        token.unclosed = true;
+        next = value.length;
+        token.sourceEndIndex = next;
+      }
+      token.value = value.slice(pos + 2, next);
+      tokens.push(token);
+      pos = next + 2;
+      code = value.charCodeAt(pos);
+    } else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
+      token = value[pos];
+      tokens.push({
+        type: "word",
+        sourceIndex: pos - before.length,
+        sourceEndIndex: pos + token.length,
+        value: token
+      });
+      pos += 1;
+      code = value.charCodeAt(pos);
+    } else if (code === slash || code === comma || code === colon) {
+      token = value[pos];
+      tokens.push({
+        type: "div",
+        sourceIndex: pos - before.length,
+        sourceEndIndex: pos + token.length,
+        value: token,
+        before,
+        after: ""
+      });
+      before = "";
+      pos += 1;
+      code = value.charCodeAt(pos);
+    } else if (openParentheses === code) {
+      next = pos;
+      do {
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (code <= 32);
+      parenthesesOpenPos = pos;
+      token = {
+        type: "function",
+        sourceIndex: pos - name.length,
+        value: name,
+        before: value.slice(parenthesesOpenPos + 1, next)
+      };
+      pos = next;
+      if (name === "url" && code !== singleQuote && code !== doubleQuote) {
+        next -= 1;
+        do {
+          escape = false;
+          next = value.indexOf(")", next + 1);
+          if (~next) {
+            escapePos = next;
+            while (value.charCodeAt(escapePos - 1) === backslash) {
+              escapePos -= 1;
+              escape = !escape;
+            }
+          } else {
+            value += ")";
+            next = value.length - 1;
+            token.unclosed = true;
+          }
+        } while (escape);
+        whitespacePos = next;
+        do {
+          whitespacePos -= 1;
+          code = value.charCodeAt(whitespacePos);
+        } while (code <= 32);
+        if (parenthesesOpenPos < whitespacePos) {
+          if (pos !== whitespacePos + 1) token.nodes = [{
+            type: "word",
+            sourceIndex: pos,
+            sourceEndIndex: whitespacePos + 1,
+            value: value.slice(pos, whitespacePos + 1)
+          }];
+          else token.nodes = [];
+          if (token.unclosed && whitespacePos + 1 !== next) {
+            token.after = "";
+            token.nodes.push({
+              type: "space",
+              sourceIndex: whitespacePos + 1,
+              sourceEndIndex: next,
+              value: value.slice(whitespacePos + 1, next)
+            });
+          } else {
+            token.after = value.slice(whitespacePos + 1, next);
+            token.sourceEndIndex = next;
+          }
+        } else {
+          token.after = "";
+          token.nodes = [];
+        }
+        pos = next + 1;
+        token.sourceEndIndex = token.unclosed ? next : pos;
+        code = value.charCodeAt(pos);
+        tokens.push(token);
+      } else {
+        balanced += 1;
+        token.after = "";
+        token.sourceEndIndex = pos + 1;
+        tokens.push(token);
+        stack.push(token);
+        tokens = token.nodes = [];
+        parent = token;
+      }
+      name = "";
+    } else if (closeParentheses === code && balanced) {
+      pos += 1;
+      code = value.charCodeAt(pos);
+      parent.after = after;
+      parent.sourceEndIndex += after.length;
+      after = "";
+      balanced -= 1;
+      stack[stack.length - 1].sourceEndIndex = pos;
+      stack.pop();
+      parent = stack[balanced];
+      tokens = parent.nodes;
+    } else {
+      next = pos;
+      do {
+        if (code === backslash) next += 1;
+        next += 1;
+        code = value.charCodeAt(next);
+      } while (next < max && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
+      token = value.slice(pos, next);
+      if (openParentheses === code) name = token;
+      else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) tokens.push({
+        type: "unicode-range",
+        sourceIndex: pos,
+        sourceEndIndex: next,
+        value: token
+      });
+      else tokens.push({
+        type: "word",
+        sourceIndex: pos,
+        sourceEndIndex: next,
+        value: token
+      });
+      pos = next;
+    }
+    for (pos = stack.length - 1; pos; pos -= 1) {
+      stack[pos].unclosed = true;
+      stack[pos].sourceEndIndex = value.length;
+    }
+    return stack[0].nodes;
+  };
+}));
+var require_walk = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  module.exports = function walk(nodes, cb, bubble) {
+    var i, max, node, result;
+    for (i = 0, max = nodes.length; i < max; i += 1) {
+      node = nodes[i];
+      if (!bubble) result = cb(node, i, nodes);
+      if (result !== false && node.type === "function" && Array.isArray(node.nodes)) walk(node.nodes, cb, bubble);
+      if (bubble) cb(node, i, nodes);
+    }
+  };
+}));
+var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  function stringifyNode(node, custom) {
+    var type = node.type;
+    var value = node.value;
+    var buf;
+    var customResult;
+    if (custom && (customResult = custom(node)) !== void 0) return customResult;
+    else if (type === "word" || type === "space") return value;
+    else if (type === "string") {
+      buf = node.quote || "";
+      return buf + value + (node.unclosed ? "" : buf);
+    } else if (type === "comment") return "/*" + value + (node.unclosed ? "" : "*/");
+    else if (type === "div") return (node.before || "") + value + (node.after || "");
+    else if (Array.isArray(node.nodes)) {
+      buf = stringify(node.nodes, custom);
+      if (type !== "function") return buf;
+      return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
+    }
+    return value;
+  }
+  function stringify(nodes, custom) {
+    var result, i;
+    if (Array.isArray(nodes)) {
+      result = "";
+      for (i = nodes.length - 1; ~i; i -= 1) result = stringifyNode(nodes[i], custom) + result;
+      return result;
+    }
+    return stringifyNode(nodes, custom);
+  }
+  module.exports = stringify;
+}));
+var require_unit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  var minus = "-".charCodeAt(0);
+  var plus = "+".charCodeAt(0);
+  var dot = ".".charCodeAt(0);
+  var exp = "e".charCodeAt(0);
+  var EXP = "E".charCodeAt(0);
+  function likeNumber(value) {
+    var code = value.charCodeAt(0);
+    var nextCode;
+    if (code === plus || code === minus) {
+      nextCode = value.charCodeAt(1);
+      if (nextCode >= 48 && nextCode <= 57) return true;
+      var nextNextCode = value.charCodeAt(2);
+      if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) return true;
+      return false;
+    }
+    if (code === dot) {
+      nextCode = value.charCodeAt(1);
+      if (nextCode >= 48 && nextCode <= 57) return true;
+      return false;
+    }
+    if (code >= 48 && code <= 57) return true;
+    return false;
+  }
+  module.exports = function(value) {
+    var pos = 0;
+    var length = value.length;
+    var code;
+    var nextCode;
+    var nextNextCode;
+    if (length === 0 || !likeNumber(value)) return false;
+    code = value.charCodeAt(pos);
+    if (code === plus || code === minus) pos++;
+    while (pos < length) {
+      code = value.charCodeAt(pos);
+      if (code < 48 || code > 57) break;
+      pos += 1;
+    }
+    code = value.charCodeAt(pos);
+    nextCode = value.charCodeAt(pos + 1);
+    if (code === dot && nextCode >= 48 && nextCode <= 57) {
+      pos += 2;
+      while (pos < length) {
+        code = value.charCodeAt(pos);
+        if (code < 48 || code > 57) break;
+        pos += 1;
+      }
+    }
+    code = value.charCodeAt(pos);
+    nextCode = value.charCodeAt(pos + 1);
+    nextNextCode = value.charCodeAt(pos + 2);
+    if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
+      pos += nextCode === plus || nextCode === minus ? 3 : 2;
+      while (pos < length) {
+        code = value.charCodeAt(pos);
+        if (code < 48 || code > 57) break;
+        pos += 1;
+      }
+    }
+    return {
+      number: value.slice(0, pos),
+      unit: value.slice(pos)
+    };
+  };
+}));
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  var parse = require_parse();
+  var walk = require_walk();
+  var stringify = require_stringify();
+  function ValueParser(value) {
+    if (this instanceof ValueParser) {
+      this.nodes = parse(value);
+      return this;
+    }
+    return new ValueParser(value);
+  }
+  ValueParser.prototype.toString = function() {
+    return Array.isArray(this.nodes) ? stringify(this.nodes) : "";
+  };
+  ValueParser.prototype.walk = function(cb, bubble) {
+    walk(this.nodes, cb, bubble);
+    return this;
+  };
+  ValueParser.unit = require_unit();
+  ValueParser.walk = walk;
+  ValueParser.stringify = stringify;
+  module.exports = ValueParser;
+}));
+
+export {
+  require_lib
+};

package/dist/chunk-7HWWVRNS.js

@@ -0,0 +1,104 @@
+// src/core/normalize.ts
+function normalize(content) {
+  let result = content;
+  result = result.replace(
+    /^(<(?:AppOnly|PagesOnly|details[^>]*|div[^>]*)>)\n(?!\n)/gm,
+    "$1\n\n"
+  );
+  result = result.replace(
+    /(?<!\n)\n(<\/(?:AppOnly|PagesOnly|details|div)>)/gm,
+    "\n\n$1"
+  );
+  result = result.replace(
+    /^(<\/(?:AppOnly|PagesOnly|details|div)>)\n(?!\n)/gm,
+    "$1\n\n"
+  );
+  return result;
+}
+
+// src/core/parser.ts
+import crypto from "crypto";
+import { remark } from "remark";
+var TRANSLATABLE_TYPES = /* @__PURE__ */ new Set([
+  "paragraph",
+  "heading",
+  "list",
+  "blockquote"
+]);
+function isHtmlPureTag(text) {
+  const lines = text.trim().split("\n");
+  return lines.every((line) => {
+    const trimmed = line.trim();
+    if (trimmed === "") return true;
+    if (/^<\w[^>]*\/>$/.test(trimmed)) return true;
+    if (/^<\/?\w[\w-]*[^>]*>$/.test(trimmed)) return true;
+    return false;
+  });
+}
+function computeHash(text) {
+  return crypto.createHash("md5").update(text).digest("hex");
+}
+var FRONTMATTER_TRANSLATABLE_FIELDS = [
+  "title",
+  "description",
+  "nav_title",
+  "related.title",
+  "related.description"
+];
+function parseMdx(rawContent) {
+  const content = normalize(rawContent);
+  const tree = remark().parse(content);
+  const nodes = [];
+  let frontmatterHandled = false;
+  if (content.startsWith("---") && tree.children.length >= 2 && tree.children[0].type === "thematicBreak") {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const fmEnd = fmMatch[0].length;
+      const fmText = fmMatch[0];
+      nodes.push({
+        type: "frontmatter",
+        rawText: fmText,
+        needsTranslation: true,
+        md5: computeHash(fmText),
+        startOffset: 0,
+        endOffset: fmEnd
+      });
+      frontmatterHandled = true;
+    }
+  }
+  for (const child of tree.children) {
+    const startOffset = child.position?.start.offset ?? 0;
+    const endOffset = child.position?.end.offset ?? 0;
+    if (frontmatterHandled && startOffset < nodes[0].endOffset) {
+      continue;
+    }
+    const rawText = content.substring(startOffset, endOffset);
+    const type = child.type;
+    let needsTranslation;
+    if (TRANSLATABLE_TYPES.has(type)) {
+      needsTranslation = true;
+    } else if (type === "html") {
+      needsTranslation = !isHtmlPureTag(rawText);
+    } else {
+      needsTranslation = false;
+    }
+    const node = {
+      type,
+      rawText,
+      needsTranslation,
+      startOffset,
+      endOffset
+    };
+    if (needsTranslation) {
+      node.md5 = computeHash(rawText);
+    }
+    nodes.push(node);
+  }
+  return nodes;
+}
+
+export {
+  normalize,
+  FRONTMATTER_TRANSLATABLE_FIELDS,
+  parseMdx
+};

package/dist/chunk-AKLW2MUS.js

@@ -0,0 +1,54 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], 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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __require,
+  __glob,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS
+};