docs-i18n 0.1.0

package/dist/chunk-O35QHRY6.js

@@ -0,0 +1,6 @@
+// node_modules/vite/misc/false.js
+var false_default = false;
+
+export {
+  false_default
+};

package/dist/chunk-PTIH4GGE.js

@@ -0,0 +1,44 @@
+// node_modules/vite/dist/node/chunks/chunk.js
+import { createRequire } from "module";
+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 __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+  let target = {};
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+  if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+  return target;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export {
+  __esmMin,
+  __commonJSMin,
+  __exportAll,
+  __toESM,
+  __toCommonJS,
+  __require
+};

package/dist/chunk-QSVWLTGQ.js

@@ -0,0 +1,60 @@
+import {
+  init_normalize,
+  init_parser,
+  normalize,
+  parseMdx
+} from "./chunk-SUIDX6IZ.js";
+
+// src/core/assembler.ts
+init_normalize();
+init_parser();
+var NEEDS_TRANSLATION_START = "<!-- NEEDS_TRANSLATION -->";
+var NEEDS_TRANSLATION_END = "<!-- /NEEDS_TRANSLATION -->";
+function assemble(rawContent, lang, cache, sourceFilePath, fallbackToSource = false) {
+  const normalizedContent = normalize(rawContent);
+  const nodes = parseMdx(rawContent);
+  let result = "";
+  let lastEnd = 0;
+  let cachedCount = 0;
+  let uncachedCount = 0;
+  let totalTranslatable = 0;
+  for (const node of nodes) {
+    result += normalizedContent.substring(lastEnd, node.startOffset);
+    if (node.needsTranslation) {
+      totalTranslatable++;
+      const cached = node.md5 ? cache.get(lang, node.md5) : void 0;
+      if (node.md5 && sourceFilePath) {
+        const line = normalizedContent.substring(0, node.startOffset).split("\n").length;
+        cache.updateSource(lang, node.md5, sourceFilePath, line);
+      }
+      if (cached) {
+        result += cached;
+        cachedCount++;
+      } else if (fallbackToSource) {
+        result += node.rawText;
+        uncachedCount++;
+      } else {
+        result += `${NEEDS_TRANSLATION_START}
+${node.rawText}
+${NEEDS_TRANSLATION_END}`;
+        uncachedCount++;
+      }
+    } else {
+      result += node.rawText;
+    }
+    lastEnd = node.endOffset;
+  }
+  result += normalizedContent.substring(lastEnd);
+  return {
+    content: result,
+    allCached: uncachedCount === 0,
+    cachedCount,
+    uncachedCount,
+    totalTranslatable,
+    parsedNodes: nodes
+  };
+}
+
+export {
+  assemble
+};

package/dist/chunk-SUIDX6IZ.js

@@ -0,0 +1,122 @@
+import {
+  __esm
+} from "./chunk-AKLW2MUS.js";
+
+// 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;
+}
+var init_normalize = __esm({
+  "src/core/normalize.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/parser.ts
+import crypto from "crypto";
+import { remark } from "remark";
+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");
+}
+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;
+}
+var TRANSLATABLE_TYPES, FRONTMATTER_TRANSLATABLE_FIELDS;
+var init_parser = __esm({
+  "src/core/parser.ts"() {
+    "use strict";
+    init_normalize();
+    TRANSLATABLE_TYPES = /* @__PURE__ */ new Set([
+      "paragraph",
+      "heading",
+      "list",
+      "blockquote"
+    ]);
+    FRONTMATTER_TRANSLATABLE_FIELDS = [
+      "title",
+      "description",
+      "nav_title",
+      "related.title",
+      "related.description"
+    ];
+  }
+});
+
+export {
+  normalize,
+  init_normalize,
+  FRONTMATTER_TRANSLATABLE_FIELDS,
+  parseMdx,
+  init_parser
+};