@dogsbay/minja 0.2.0-beta.92 → 0.2.0-beta.98

package/dist/index.umd.js

@@ -1,5 +1,5 @@
 /**
- * minja v0.2.0-beta.92
+ * minja v0.2.0-beta.98
  * Minimal, secure Jinja2/Nunjucks subset for documentation preprocessing
  * @license MIT
  */
@@ -29,10 +29,16 @@ var minja = (() => {
     Context: () => Context,
     FetchLoader: () => FetchLoader,
     MemoryLoader: () => MemoryLoader,
+    commentRe: () => commentRe,
+    directiveTagRe: () => directiveTagRe,
     evaluateExpression: () => evaluateExpression,
+    includeDirectiveRe: () => includeDirectiveRe,
     parse: () => parse,
     parseExpression: () => parseExpression,
-    render: () => render
+    rawBlockRe: () => rawBlockRe,
+    render: () => render,
+    scanIncludes: () => scanIncludes,
+    variableRe: () => variableRe
   });
 
   // src/evaluator.ts
@@ -195,6 +201,24 @@ var minja = (() => {
   }
 
   // src/parser.ts
+  var KNOWN_TAG_KEYWORDS = /* @__PURE__ */ new Set([
+    "set",
+    "if",
+    "include",
+    "switch",
+    "leveloffset",
+    "raw",
+    "endif",
+    "elif",
+    "else",
+    "endswitch",
+    "case",
+    "endleveloffset",
+    "endraw"
+  ]);
+  function stripBodyForEndTag(body, endTag) {
+    return endTag.startsWith("{%-") ? body.replace(/[ \t]*\n[ \t\n]*$/, "") : body;
+  }
   function parse(template) {
     const errors = [];
     const ast = [];
@@ -277,12 +301,57 @@ var minja = (() => {
           }
         }
       } else if (nearest.type === "tag") {
+        const tagStart2 = position;
         advance(2);
         const endPos = findNext("%}", position);
         if (endPos === -1) {
           errors.push(createError("Unclosed statement tag"));
           break;
         }
+        const peeked = template.substring(position, endPos).trim();
+        const peekKeyword = peeked.replace(/^-\s*/, "").replace(/\s*-$/, "").split(/\s+/)[0] ?? "";
+        if (peekKeyword === "raw") {
+          const openerLeftStrip = peeked.startsWith("-");
+          const openerRightStrip = peeked.endsWith("-");
+          if (openerLeftStrip && ast.length > 0 && ast[ast.length - 1].type === "text") {
+            const lastNode = ast[ast.length - 1];
+            lastNode.value = lastNode.value.replace(/[ \t]*\n[ \t\n]*$/, "");
+          }
+          extractTo(endPos);
+          advance(2);
+          if (openerRightStrip) {
+            while (position < template.length && /[ \t\n]/.test(template[position])) {
+              advance(1);
+            }
+          }
+          const endrawMatch = /\{%-?\s*endraw\s*-?%\}/.exec(template.substring(position));
+          if (!endrawMatch) {
+            errors.push(createError("Unclosed raw block"));
+            break;
+          }
+          const endrawAbs = position + endrawMatch.index;
+          let content = extractTo(endrawAbs);
+          const endrawTag = endrawMatch[0];
+          if (endrawTag.startsWith("{%-")) {
+            content = content.replace(/[ \t]*\n[ \t\n]*$/, "");
+          }
+          advance(endrawTag.length);
+          if (endrawTag.endsWith("-%}")) {
+            while (position < template.length && /[ \t\n]/.test(template[position])) {
+              advance(1);
+            }
+          }
+          if (content) {
+            ast.push({ type: "text", value: content });
+          }
+          continue;
+        }
+        if (!KNOWN_TAG_KEYWORDS.has(peekKeyword)) {
+          extractTo(endPos);
+          advance(2);
+          ast.push({ type: "text", value: template.substring(tagStart2, endPos + 2) });
+          continue;
+        }
         let statement = extractTo(endPos).trim();
         const hasLeftStrip = statement.startsWith("-");
         const hasRightStrip = statement.endsWith("-");
@@ -416,12 +485,13 @@ var minja = (() => {
     }
     return { ast, errors };
     function findEndTag(tagName) {
-      const pattern = new RegExp(`{%\\s*${tagName}\\s*%}`);
+      const pattern = new RegExp(`{%-?\\s*${tagName}\\s*-?%}`);
       const match = pattern.exec(template.substring(position));
       if (match) {
         return {
           start: position + match.index,
-          length: match[0].length
+          length: match[0].length,
+          tag: match[0]
         };
       }
       return null;
@@ -453,8 +523,12 @@ var minja = (() => {
           searchPos = nearest.pos + nearest.match[0].length;
         } else if (nearest.type === "endif") {
           if (depth === 0) {
-            const bodyTemplate = extractTo(nearest.pos);
+            const bodyTemplate = stripBodyForEndTag(extractTo(nearest.pos), nearest.match[0]);
             advance(nearest.match[0].length);
+            if (nearest.match[0].endsWith("-%}")) {
+              while (position < template.length && /[ \t\n]/.test(template[position]))
+                advance(1);
+            }
             const bodyResult = parse(bodyTemplate);
             parseErrors.push(...bodyResult.errors);
             return {
@@ -468,7 +542,7 @@ var minja = (() => {
             searchPos = nearest.pos + nearest.match[0].length;
           }
         } else if (depth === 0 && (nearest.type === "elif" || nearest.type === "else")) {
-          const bodyTemplate = extractTo(nearest.pos);
+          const bodyTemplate = stripBodyForEndTag(extractTo(nearest.pos), nearest.match[0]);
           const bodyResult = parse(bodyTemplate);
           if (elifBranches.length === 0 && elseBranch.length === 0) {
             parseErrors.push(...bodyResult.errors);
@@ -505,7 +579,10 @@ var minja = (() => {
               if (!endifMatch2) {
                 parseErrors.push(createError("Missing endif after else"));
               } else {
-                const elseBodyTemplate = extractTo(endifMatch2.start);
+                const elseBodyTemplate = stripBodyForEndTag(
+                  extractTo(endifMatch2.start),
+                  endifMatch2.tag
+                );
                 advance(endifMatch2.length);
                 const elseBodyResult = parse(elseBodyTemplate);
                 parseErrors.push(...elseBodyResult.errors);
@@ -691,15 +768,38 @@ var minja = (() => {
   };
 
   // src/renderer.ts
-  function transformHeadings(text, offset) {
+  function transformHeadings(text, offset, initialFence = null, fenceOut) {
     if (offset === 0) {
+      if (fenceOut)
+        fenceOut.fence = initialFence;
       return text;
     }
-    return text.replace(/^(#{1,6})(\s+)/gm, (_match, hashes, space) => {
-      const currentLevel = hashes.length;
-      const newLevel = Math.max(1, Math.min(6, currentLevel + offset));
-      return "#".repeat(newLevel) + space;
-    });
+    const lines = text.split("\n");
+    let fence = initialFence;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const fenceMatch = line.match(/^\s*(`{3,}|~{3,})/);
+      if (fenceMatch) {
+        const run = fenceMatch[1];
+        if (fence === null) {
+          fence = run;
+        } else if (run[0] === fence[0] && run.length >= fence.length && line.trim() === run) {
+          fence = null;
+        }
+        continue;
+      }
+      if (fence !== null) {
+        continue;
+      }
+      const m = line.match(/^(#{1,6})(\s+)/);
+      if (m) {
+        const newLevel = Math.max(1, Math.min(6, m[1].length + offset));
+        lines[i] = "#".repeat(newLevel) + line.slice(m[1].length);
+      }
+    }
+    if (fenceOut)
+      fenceOut.fence = fence;
+    return lines.join("\n");
   }
   function resolvePath(path, basePath) {
     if (path.startsWith("/")) {
@@ -770,7 +870,14 @@ var minja = (() => {
   async function renderNodes(nodes, options) {
     const parts = [];
     for (const node of nodes) {
-      parts.push(await renderNode(node, options));
+      let rendered = await renderNode(node, options);
+      if (node.type === "include" && rendered && parts.length > 0) {
+        const tail = /(?:^|\n)([ \t]+)$/.exec(parts[parts.length - 1]);
+        if (tail) {
+          rendered = rendered.replace(/\n(?=[^\n])/g, "\n" + tail[1]);
+        }
+      }
+      parts.push(rendered);
     }
     return parts.join("");
   }
@@ -782,7 +889,15 @@ var minja = (() => {
         if (currentOffset === 0) {
           return node.value;
         }
-        return transformHeadings(node.value, currentOffset);
+        const fenceOut = { fence: null };
+        const out = transformHeadings(
+          node.value,
+          currentOffset,
+          context.get("_levelOffsetFence") ?? null,
+          fenceOut
+        );
+        context.set("_levelOffsetFence", fenceOut.fence);
+        return out;
       }
       case "variable": {
         const value = context.get(node.name);
@@ -792,6 +907,8 @@ var minja = (() => {
               throw new Error(`Undefined variable: ${node.name}`);
             case "preserve":
               return `{{ ${node.name} }}`;
+            case "asciidoc-literal":
+              return `{${node.name}}`;
             case "empty":
             default:
               return "";
@@ -811,7 +928,7 @@ var minja = (() => {
       case "comment":
         return "";
       case "if": {
-        if (options.undefinedBehavior === "preserve" && options.undefinedConditions !== "falsy") {
+        if ((options.undefinedBehavior === "preserve" || options.undefinedBehavior === "asciidoc-literal") && options.undefinedConditions !== "falsy") {
           const undefinedRefs = findUndefinedRefs(node.condition, context);
           if (undefinedRefs.length > 0) {
             return ifNodeToSource(node);
@@ -871,7 +988,10 @@ var minja = (() => {
             undefinedConditions: options.undefinedConditions
           });
         } catch (error) {
-          if (options.undefinedBehavior === "preserve") {
+          if (error instanceof Error && error.name === "IncludeContainmentError") {
+            throw error;
+          }
+          if (options.undefinedBehavior === "preserve" || options.undefinedBehavior === "asciidoc-literal") {
             return `{% include "${node.path}" %}`;
           }
           const message = error instanceof Error ? error.message : String(error);
@@ -894,11 +1014,14 @@ var minja = (() => {
         const newOffset = node.isRelative ? parentOffset + node.offset : node.offset;
         const previousOffset = parentOffset;
         context.set("_levelOffset", newOffset);
+        const previousFence = context.get("_levelOffsetFence") ?? null;
+        context.set("_levelOffsetFence", null);
         try {
           const result = await renderNodes(node.body, options);
           return result;
         } finally {
           context.set("_levelOffset", previousOffset);
+          context.set("_levelOffsetFence", previousFence);
         }
       }
       default:
@@ -1024,6 +1147,14 @@ var minja = (() => {
       return content;
     }
   };
+
+  // src/scan.ts
+  var includeDirectiveRe = () => /\{%-?\s*include\s+["']([^"']+)["']\s*-?%\}/g;
+  var scanIncludes = (text) => [...text.matchAll(includeDirectiveRe())].map((match) => match[1]);
+  var variableRe = () => /\{\{-?([\s\S]*?)-?\}\}/g;
+  var directiveTagRe = () => /\{%-?\s*([A-Za-z_][A-Za-z0-9_]*)([\s\S]*?)-?%\}/g;
+  var commentRe = () => /\{#[\s\S]*?#\}/g;
+  var rawBlockRe = () => /\{%-?\s*raw\s*-?%\}([\s\S]*?)\{%-?\s*endraw\s*-?%\}/g;
   return __toCommonJS(browser_exports);
 })();
 //# sourceMappingURL=index.umd.js.map