docusaurus-plugin-glossary 3.0.2 → 3.2.0

package/dist/remark/glossary-terms.cjs

@@ -0,0 +1,345 @@
+"use strict";
+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 __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);
+
+// src/remark/glossary-terms.js
+var glossary_terms_exports = {};
+__export(glossary_terms_exports, {
+  clearGlossaryCache: () => clearGlossaryCache,
+  default: () => remarkGlossaryTerms
+});
+module.exports = __toCommonJS(glossary_terms_exports);
+var import_unist_util_visit = require("unist-util-visit");
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+function validateGlossaryTerms(data, _filePath) {
+  const errors = [];
+  const validTerms = [];
+  if (data === null || data === void 0) {
+    errors.push(`Glossary data is null or undefined`);
+    return { terms: [], errors };
+  }
+  if (typeof data !== "object") {
+    errors.push(`Glossary data must be an object, got ${typeof data}`);
+    return { terms: [], errors };
+  }
+  if (!("terms" in data)) {
+    errors.push(`Glossary data must contain a "terms" array`);
+    return { terms: [], errors };
+  }
+  if (!Array.isArray(data.terms)) {
+    errors.push(`Field "terms" must be an array, got ${typeof data.terms}`);
+    return { terms: [], errors };
+  }
+  data.terms.forEach((term, index) => {
+    if (term === null || term === void 0 || typeof term !== "object") {
+      errors.push(`terms[${index}]: Term must be an object`);
+      return;
+    }
+    if (typeof term.term !== "string" || term.term.trim() === "") {
+      errors.push(`terms[${index}]: Missing or invalid "term" field`);
+      return;
+    }
+    if (typeof term.definition !== "string") {
+      errors.push(`terms[${index}]: Missing or invalid "definition" field`);
+      return;
+    }
+    validTerms.push(term);
+  });
+  return { terms: validTerms, errors };
+}
+var glossaryCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5e3;
+function remarkGlossaryTerms({
+  terms = [],
+  glossaryPath = null,
+  routePath = "/glossary",
+  siteDir = null
+} = {}) {
+  let glossaryTerms = terms;
+  if (!glossaryTerms.length && glossaryPath && siteDir) {
+    try {
+      const glossaryFilePath = import_path.default.resolve(siteDir, glossaryPath);
+      const now = Date.now();
+      const cached = glossaryCache.get(glossaryFilePath);
+      if (cached && now - cached.loadedAt < CACHE_TTL) {
+        glossaryTerms = cached.terms;
+      } else {
+        if (import_fs.default.existsSync(glossaryFilePath)) {
+          const fileContent = import_fs.default.readFileSync(glossaryFilePath, "utf8");
+          let glossaryData;
+          try {
+            glossaryData = JSON.parse(fileContent);
+          } catch (parseError) {
+            console.error(
+              `[glossary-plugin] Failed to parse glossary JSON at ${glossaryPath}:`,
+              parseError.message
+            );
+            glossaryCache.set(glossaryFilePath, {
+              terms: [],
+              loadedAt: now
+            });
+            return (tree) => tree;
+          }
+          const { terms: validTerms, errors } = validateGlossaryTerms(glossaryData, glossaryPath);
+          if (errors.length > 0) {
+            console.warn(`[glossary-plugin] Glossary validation errors in ${glossaryPath}:`);
+            errors.forEach((err) => console.warn(`  - ${err}`));
+            if (validTerms.length > 0) {
+              console.warn(`[glossary-plugin] Proceeding with ${validTerms.length} valid term(s).`);
+            }
+          }
+          glossaryTerms = validTerms;
+          glossaryCache.set(glossaryFilePath, {
+            terms: glossaryTerms,
+            loadedAt: now
+          });
+          if (!cached && process.env.NODE_ENV !== "production") {
+            console.log(
+              `[glossary-plugin] Loaded ${glossaryTerms.length} terms from ${glossaryPath}`
+            );
+          }
+        } else {
+          glossaryCache.set(glossaryFilePath, {
+            terms: [],
+            loadedAt: now
+          });
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(`[glossary-plugin] Glossary file not found: ${glossaryPath}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(
+        `[glossary-plugin] Failed to load glossary from ${glossaryPath}:`,
+        error.message
+      );
+      if (glossaryPath && siteDir) {
+        const glossaryFilePath = import_path.default.resolve(siteDir, glossaryPath);
+        glossaryCache.set(glossaryFilePath, {
+          terms: [],
+          loadedAt: Date.now()
+        });
+      }
+    }
+  }
+  const termMap = /* @__PURE__ */ new Map();
+  glossaryTerms.forEach((termObj) => {
+    if (termObj.term && termObj.autoLink !== false) {
+      termMap.set(termObj.term.toLowerCase(), termObj);
+    }
+  });
+  const sortedTerms = Array.from(termMap.entries()).sort((a, b) => b[0].length - a[0].length);
+  if (sortedTerms.length === 0) {
+    return (tree) => tree;
+  }
+  function replaceTermsInText(text) {
+    if (!text || !sortedTerms.length) {
+      return [{ type: "text", value: text }];
+    }
+    const result = [];
+    let lastIndex = 0;
+    const textLower = text.toLowerCase();
+    const matches = [];
+    for (const [lowerTerm, termObj] of sortedTerms) {
+      const term = termObj.term;
+      let searchIndex = 0;
+      while (searchIndex < textLower.length) {
+        const index = textLower.indexOf(lowerTerm, searchIndex);
+        if (index === -1) break;
+        const beforeChar = index > 0 ? textLower[index - 1] : " ";
+        const afterIndex = index + lowerTerm.length;
+        const afterChar = afterIndex < textLower.length ? textLower[afterIndex] : " ";
+        let matchLength = term.length;
+        let isWordBoundary = !/\w/.test(beforeChar) && !/\w/.test(afterChar);
+        if (!isWordBoundary && afterChar === "s") {
+          const nextChar = afterIndex + 1 < textLower.length ? textLower[afterIndex + 1] : " ";
+          if (!/\w/.test(nextChar)) {
+            isWordBoundary = true;
+            matchLength = term.length + 1;
+          }
+        }
+        if (!isWordBoundary && afterChar === "e" && afterIndex + 1 < textLower.length && textLower[afterIndex + 1] === "s") {
+          const nextChar = afterIndex + 2 < textLower.length ? textLower[afterIndex + 2] : " ";
+          if (!/\w/.test(nextChar)) {
+            isWordBoundary = true;
+            matchLength = term.length + 2;
+          }
+        }
+        if (isWordBoundary) {
+          matches.push({
+            index,
+            length: matchLength,
+            term,
+            termObj,
+            // Store original case from the text
+            originalText: text.substring(index, index + matchLength)
+          });
+        }
+        searchIndex = index + 1;
+      }
+    }
+    matches.sort((a, b) => a.index - b.index);
+    const nonOverlappingMatches = [];
+    let lastMatchEnd = 0;
+    for (const match of matches) {
+      if (match.index >= lastMatchEnd) {
+        nonOverlappingMatches.push(match);
+        lastMatchEnd = match.index + match.length;
+      }
+    }
+    for (const match of nonOverlappingMatches) {
+      if (match.index > lastIndex) {
+        result.push({
+          type: "text",
+          value: text.substring(lastIndex, match.index)
+        });
+      }
+      result.push({
+        type: "mdxJsxFlowElement",
+        name: "GlossaryTerm",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "term",
+            value: match.termObj.term
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "definition",
+            value: match.termObj.definition || ""
+          },
+          {
+            type: "mdxJsxAttribute",
+            name: "routePath",
+            value: routePath
+          }
+        ],
+        children: [
+          {
+            type: "text",
+            value: match.originalText
+          }
+        ]
+      });
+      lastIndex = match.index + match.length;
+    }
+    if (lastIndex < text.length) {
+      result.push({
+        type: "text",
+        value: text.substring(lastIndex)
+      });
+    }
+    return result.length > 0 ? result : [{ type: "text", value: text }];
+  }
+  const transformer = (tree) => {
+    let usedGlossaryTerm = false;
+    (0, import_unist_util_visit.visit)(tree, "text", (node, index, parent) => {
+      if (parent.type === "code" || parent.type === "inlineCode" || parent.type === "link" || parent.type === "mdxJsxFlowElement" || parent.type === "mdxJsxTextElement") {
+        return;
+      }
+      const replacements = replaceTermsInText(node.value);
+      if (replacements.length > 1 || replacements.length === 1 && replacements[0].type !== "text") {
+        const newNodes = replacements.map((replacement) => {
+          if (replacement.type === "mdxJsxFlowElement") {
+            if (parent.type === "paragraph") {
+              usedGlossaryTerm = true;
+              return {
+                type: "mdxJsxTextElement",
+                name: replacement.name,
+                attributes: replacement.attributes,
+                children: replacement.children
+              };
+            }
+            usedGlossaryTerm = true;
+          }
+          return replacement;
+        });
+        parent.children.splice(index, 1, ...newNodes);
+        return index + newNodes.length - 1;
+      }
+    });
+    if (usedGlossaryTerm) {
+      const importNode = {
+        type: "mdxjsEsm",
+        value: 'import GlossaryTerm from "@theme/GlossaryTerm";',
+        data: {
+          estree: {
+            type: "Program",
+            sourceType: "module",
+            body: [
+              {
+                type: "ImportDeclaration",
+                specifiers: [
+                  {
+                    type: "ImportDefaultSpecifier",
+                    local: { type: "Identifier", name: "GlossaryTerm" }
+                  }
+                ],
+                source: {
+                  type: "Literal",
+                  value: "@theme/GlossaryTerm",
+                  raw: '"@theme/GlossaryTerm"'
+                }
+              }
+            ]
+          }
+        }
+      };
+      const hasImport = Array.isArray(tree.children) && tree.children.some(
+        (n) => n.type === "mdxjsEsm" && (n.value?.includes("@theme/GlossaryTerm") || n.data?.estree?.body?.some((s) => s.source?.value === "@theme/GlossaryTerm"))
+      );
+      if (!hasImport) {
+        if (!Array.isArray(tree.children)) tree.children = [];
+        let insertIndex = 0;
+        for (let i = 0; i < tree.children.length; i++) {
+          const node = tree.children[i];
+          if (node.type === "yaml" || node.type === "toml") {
+            insertIndex = i + 1;
+          } else {
+            break;
+          }
+        }
+        tree.children.splice(insertIndex, 0, importNode);
+      }
+    }
+  };
+  return transformer;
+}
+function clearGlossaryCache(filePath) {
+  if (filePath) {
+    glossaryCache.delete(filePath);
+  } else {
+    glossaryCache.clear();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearGlossaryCache
+});
+//# sourceMappingURL=glossary-terms.cjs.map

package/dist/remark/glossary-terms.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/remark/glossary-terms.js"],"sourcesContent":["import { visit } from 'unist-util-visit';\nimport path from 'path';\nimport fs from 'fs';\n\n/**\n * Simple validation for glossary terms loaded from file\n * Returns only valid terms with required fields\n *\n * @param {unknown} data - The parsed JSON data\n * @param {string} filePath - Path to the file (for error messages)\n * @returns {{ terms: Array<{term: string, definition: string}>, errors: string[] }}\n */\nfunction validateGlossaryTerms(data, _filePath) {\n  const errors = [];\n  const validTerms = [];\n\n  if (data === null || data === undefined) {\n    errors.push(`Glossary data is null or undefined`);\n    return { terms: [], errors };\n  }\n\n  if (typeof data !== 'object') {\n    errors.push(`Glossary data must be an object, got ${typeof data}`);\n    return { terms: [], errors };\n  }\n\n  if (!('terms' in data)) {\n    errors.push(`Glossary data must contain a \"terms\" array`);\n    return { terms: [], errors };\n  }\n\n  if (!Array.isArray(data.terms)) {\n    errors.push(`Field \"terms\" must be an array, got ${typeof data.terms}`);\n    return { terms: [], errors };\n  }\n\n  data.terms.forEach((term, index) => {\n    if (term === null || term === undefined || typeof term !== 'object') {\n      errors.push(`terms[${index}]: Term must be an object`);\n      return;\n    }\n\n    if (typeof term.term !== 'string' || term.term.trim() === '') {\n      errors.push(`terms[${index}]: Missing or invalid \"term\" field`);\n      return;\n    }\n\n    if (typeof term.definition !== 'string') {\n      errors.push(`terms[${index}]: Missing or invalid \"definition\" field`);\n      return;\n    }\n\n    validTerms.push(term);\n  });\n\n  return { terms: validTerms, errors };\n}\n\n// Cache for glossary data to avoid repeated synchronous file reads\n// Key: absolute file path, Value: { terms, loadedAt }\nconst glossaryCache = new Map();\nconst CACHE_TTL = 5000; // 5 seconds TTL to allow for file changes during dev\n\n/**\n * Creates a remark plugin that automatically detects and replaces glossary terms in markdown\n *\n * This plugin transforms plain text terms into <GlossaryTerm> JSX elements.\n * The GlossaryTerm component is globally available via the MDXComponents theme wrapper,\n * so no import injection is needed - MDX files can use it without explicit imports.\n *\n * @param {object} options - Plugin options\n * @param {Array} options.terms - Array of glossary term objects with {term, definition}\n * @param {string} options.glossaryPath - Path to glossary JSON file (optional, if terms not provided)\n * @param {string} options.routePath - Route path to glossary page (default: '/glossary')\n * @param {string} options.siteDir - Docusaurus site directory (required if using glossaryPath)\n * @returns {function} Remark plugin function\n */\nexport default function remarkGlossaryTerms({\n  terms = [],\n  glossaryPath = null,\n  routePath = '/glossary',\n  siteDir = null,\n} = {}) {\n  let glossaryTerms = terms;\n\n  // If terms not provided, try to load from glossaryPath with caching\n  if (!glossaryTerms.length && glossaryPath && siteDir) {\n    try {\n      const glossaryFilePath = path.resolve(siteDir, glossaryPath);\n      const now = Date.now();\n\n      // Check cache first to avoid repeated file reads\n      const cached = glossaryCache.get(glossaryFilePath);\n      if (cached && now - cached.loadedAt < CACHE_TTL) {\n        glossaryTerms = cached.terms;\n      } else {\n        // Cache miss or expired - load from file synchronously\n        // Note: This is synchronous I/O which can block the build process\n        // Consider passing terms directly to avoid this\n        if (fs.existsSync(glossaryFilePath)) {\n          const fileContent = fs.readFileSync(glossaryFilePath, 'utf8');\n          let glossaryData;\n          try {\n            glossaryData = JSON.parse(fileContent);\n          } catch (parseError) {\n            console.error(\n              `[glossary-plugin] Failed to parse glossary JSON at ${glossaryPath}:`,\n              parseError.message\n            );\n            glossaryCache.set(glossaryFilePath, {\n              terms: [],\n              loadedAt: now,\n            });\n            return tree => tree;\n          }\n\n          // Validate glossary data\n          const { terms: validTerms, errors } = validateGlossaryTerms(glossaryData, glossaryPath);\n\n          if (errors.length > 0) {\n            console.warn(`[glossary-plugin] Glossary validation errors in ${glossaryPath}:`);\n            errors.forEach(err => console.warn(`  - ${err}`));\n            if (validTerms.length > 0) {\n              console.warn(`[glossary-plugin] Proceeding with ${validTerms.length} valid term(s).`);\n            }\n          }\n\n          glossaryTerms = validTerms;\n\n          // Update cache\n          glossaryCache.set(glossaryFilePath, {\n            terms: glossaryTerms,\n            loadedAt: now,\n          });\n\n          // Log only once per file (when cache is first populated)\n          if (!cached && process.env.NODE_ENV !== 'production') {\n            console.log(\n              `[glossary-plugin] Loaded ${glossaryTerms.length} terms from ${glossaryPath}`\n            );\n          }\n        } else {\n          // File doesn't exist - cache empty result to avoid repeated checks\n          glossaryCache.set(glossaryFilePath, {\n            terms: [],\n            loadedAt: now,\n          });\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(`[glossary-plugin] Glossary file not found: ${glossaryPath}`);\n          }\n        }\n      }\n    } catch (error) {\n      console.warn(\n        `[glossary-plugin] Failed to load glossary from ${glossaryPath}:`,\n        error.message\n      );\n      // Cache the error to avoid repeated attempts\n      if (glossaryPath && siteDir) {\n        const glossaryFilePath = path.resolve(siteDir, glossaryPath);\n        glossaryCache.set(glossaryFilePath, {\n          terms: [],\n          loadedAt: Date.now(),\n        });\n      }\n    }\n  }\n\n  // Build a map of terms for efficient lookup, skipping terms with autoLink: false\n  // Key: lowercase term, Value: term object with original case\n  const termMap = new Map();\n  glossaryTerms.forEach(termObj => {\n    if (termObj.term && termObj.autoLink !== false) {\n      termMap.set(termObj.term.toLowerCase(), termObj);\n    }\n  });\n\n  // Sort terms by length (longest first) to avoid partial matches\n  // e.g., \"Application Programming Interface\" should match before \"API\"\n  const sortedTerms = Array.from(termMap.entries()).sort((a, b) => b[0].length - a[0].length);\n\n  // If no terms, return a no-op transformer\n  if (sortedTerms.length === 0) {\n    return tree => tree;\n  }\n\n  /**\n   * Recursively replace glossary terms in text\n   * Returns an array of text nodes and MDX components\n   */\n  function replaceTermsInText(text) {\n    if (!text || !sortedTerms.length) {\n      return [{ type: 'text', value: text }];\n    }\n\n    const result = [];\n    let lastIndex = 0;\n    const textLower = text.toLowerCase();\n\n    // Find all matches\n    const matches = [];\n    for (const [lowerTerm, termObj] of sortedTerms) {\n      const term = termObj.term;\n      let searchIndex = 0;\n\n      while (searchIndex < textLower.length) {\n        const index = textLower.indexOf(lowerTerm, searchIndex);\n        if (index === -1) break;\n\n        // Check if it's a whole word match, with simple plural tolerance ('s' or 'es')\n        const beforeChar = index > 0 ? textLower[index - 1] : ' ';\n        const afterIndex = index + lowerTerm.length;\n        const afterChar = afterIndex < textLower.length ? textLower[afterIndex] : ' ';\n\n        let matchLength = term.length;\n        let isWordBoundary = !/\\w/.test(beforeChar) && !/\\w/.test(afterChar);\n\n        // Allow trailing 's' plural (e.g., webhook -> webhooks)\n        if (!isWordBoundary && afterChar === 's') {\n          const nextChar = afterIndex + 1 < textLower.length ? textLower[afterIndex + 1] : ' ';\n          if (!/\\w/.test(nextChar)) {\n            isWordBoundary = true;\n            matchLength = term.length + 1;\n          }\n        }\n\n        // Allow trailing 'es' plural (e.g., API -> APIs, box -> boxes)\n        if (\n          !isWordBoundary &&\n          afterChar === 'e' &&\n          afterIndex + 1 < textLower.length &&\n          textLower[afterIndex + 1] === 's'\n        ) {\n          const nextChar = afterIndex + 2 < textLower.length ? textLower[afterIndex + 2] : ' ';\n          if (!/\\w/.test(nextChar)) {\n            isWordBoundary = true;\n            matchLength = term.length + 2;\n          }\n        }\n\n        if (isWordBoundary) {\n          matches.push({\n            index,\n            length: matchLength,\n            term: term,\n            termObj: termObj,\n            // Store original case from the text\n            originalText: text.substring(index, index + matchLength),\n          });\n        }\n\n        searchIndex = index + 1;\n      }\n    }\n\n    // Sort matches by index\n    matches.sort((a, b) => a.index - b.index);\n\n    // Remove overlapping matches (keep the first one)\n    const nonOverlappingMatches = [];\n    let lastMatchEnd = 0;\n    for (const match of matches) {\n      if (match.index >= lastMatchEnd) {\n        nonOverlappingMatches.push(match);\n        lastMatchEnd = match.index + match.length;\n      }\n    }\n\n    // Build result array\n    for (const match of nonOverlappingMatches) {\n      // Add text before match\n      if (match.index > lastIndex) {\n        result.push({\n          type: 'text',\n          value: text.substring(lastIndex, match.index),\n        });\n      }\n\n      // Add MDX component for glossary term\n      result.push({\n        type: 'mdxJsxFlowElement',\n        name: 'GlossaryTerm',\n        attributes: [\n          {\n            type: 'mdxJsxAttribute',\n            name: 'term',\n            value: match.termObj.term,\n          },\n          {\n            type: 'mdxJsxAttribute',\n            name: 'definition',\n            value: match.termObj.definition || '',\n          },\n          {\n            type: 'mdxJsxAttribute',\n            name: 'routePath',\n            value: routePath,\n          },\n        ],\n        children: [\n          {\n            type: 'text',\n            value: match.originalText,\n          },\n        ],\n      });\n\n      lastIndex = match.index + match.length;\n    }\n\n    // Add remaining text\n    if (lastIndex < text.length) {\n      result.push({\n        type: 'text',\n        value: text.substring(lastIndex),\n      });\n    }\n\n    return result.length > 0 ? result : [{ type: 'text', value: text }];\n  }\n\n  // Return the transformer function\n  const transformer = tree => {\n    let usedGlossaryTerm = false;\n    visit(tree, 'text', (node, index, parent) => {\n      // Skip text nodes inside code blocks, links, or existing MDX components\n      if (\n        parent.type === 'code' ||\n        parent.type === 'inlineCode' ||\n        parent.type === 'link' ||\n        parent.type === 'mdxJsxFlowElement' ||\n        parent.type === 'mdxJsxTextElement'\n      ) {\n        return;\n      }\n\n      // Replace terms in text node\n      const replacements = replaceTermsInText(node.value);\n\n      // If we have replacements, replace the single text node with multiple nodes\n      if (\n        replacements.length > 1 ||\n        (replacements.length === 1 && replacements[0].type !== 'text')\n      ) {\n        // Convert to text elements for paragraph context if needed\n        const newNodes = replacements.map(replacement => {\n          if (replacement.type === 'mdxJsxFlowElement') {\n            // In paragraph context, we need mdxJsxTextElement instead\n            if (parent.type === 'paragraph') {\n              usedGlossaryTerm = true;\n              return {\n                type: 'mdxJsxTextElement',\n                name: replacement.name,\n                attributes: replacement.attributes,\n                children: replacement.children,\n              };\n            }\n            usedGlossaryTerm = true;\n          }\n          return replacement;\n        });\n\n        // Replace the single node with multiple nodes\n        parent.children.splice(index, 1, ...newNodes);\n        return index + newNodes.length - 1; // Return new index to continue\n      }\n    });\n\n    // Inject MDX import for GlossaryTerm if we used it\n    // The component is available via theme path, so we just need to import it\n    if (usedGlossaryTerm) {\n      const importNode = {\n        type: 'mdxjsEsm',\n        value: 'import GlossaryTerm from \"@theme/GlossaryTerm\";',\n        data: {\n          estree: {\n            type: 'Program',\n            sourceType: 'module',\n            body: [\n              {\n                type: 'ImportDeclaration',\n                specifiers: [\n                  {\n                    type: 'ImportDefaultSpecifier',\n                    local: { type: 'Identifier', name: 'GlossaryTerm' },\n                  },\n                ],\n                source: {\n                  type: 'Literal',\n                  value: '@theme/GlossaryTerm',\n                  raw: '\"@theme/GlossaryTerm\"',\n                },\n              },\n            ],\n          },\n        },\n      };\n\n      // Check for existing import\n      const hasImport =\n        Array.isArray(tree.children) &&\n        tree.children.some(\n          n =>\n            n.type === 'mdxjsEsm' &&\n            (n.value?.includes('@theme/GlossaryTerm') ||\n              n.data?.estree?.body?.some(s => s.source?.value === '@theme/GlossaryTerm'))\n        );\n\n      if (!hasImport) {\n        if (!Array.isArray(tree.children)) tree.children = [];\n        let insertIndex = 0;\n        for (let i = 0; i < tree.children.length; i++) {\n          const node = tree.children[i];\n          if (node.type === 'yaml' || node.type === 'toml') {\n            insertIndex = i + 1;\n          } else {\n            break;\n          }\n        }\n        tree.children.splice(insertIndex, 0, importNode);\n      }\n    }\n  };\n\n  return transformer;\n}\n\n/**\n * Clears the glossary cache\n * Useful for testing or when you want to force a reload of glossary data\n *\n * @param {string} [filePath] - Optional specific file path to clear. If not provided, clears entire cache.\n */\nexport function clearGlossaryCache(filePath) {\n  if (filePath) {\n    glossaryCache.delete(filePath);\n  } else {\n    glossaryCache.clear();\n  }\n}\n"],"mappings":"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","names":["path","fs"]}