spec-up-t 1.2.8 → 1.3.0-beta

package/src/html-dom-processor.js

@@ -0,0 +1,290 @@
+'use strict';
+
+const { JSDOM } = require('jsdom');
+
+/**
+ * Sorts definition terms in HTML alphabetically (case-insensitive)
+ * 
+ * @param {string} html - The HTML content to process
+ * @returns {string} - The HTML with sorted definition terms
+ */
+function sortDefinitionTermsInHtml(html) {
+  const dom = new JSDOM(html);
+  const document = dom.window.document;
+
+  // Find the terms and definitions list
+  const dlElement = document.querySelector('.terms-and-definitions-list');
+  if (!dlElement) return html; // If not found, return the original HTML
+
+  // Collect all dt/dd pairs
+  const pairs = [];
+  let currentDt = null;
+  let currentDds = [];
+
+  // Process each child of the dl element
+  Array.from(dlElement.children).forEach(child => {
+    if (child.tagName === 'DT') {
+      // If we already have a dt, save the current pair
+      if (currentDt) {
+        pairs.push({
+          dt: currentDt,
+          dds: [...currentDds],
+          text: currentDt.textContent.trim().toLowerCase() // Use lowercase for sorting
+        });
+        currentDds = []; // Reset dds for the next dt
+      }
+      currentDt = child;
+    } else if (child.tagName === 'DD' && currentDt) {
+      currentDds.push(child);
+    }
+  });
+
+  // Add the last pair if exists
+  if (currentDt) {
+    pairs.push({
+      dt: currentDt,
+      dds: [...currentDds],
+      text: currentDt.textContent.trim().toLowerCase()
+    });
+  }
+
+  // Sort pairs case-insensitively
+  pairs.sort((a, b) => a.text.localeCompare(b.text));
+
+  // Clear the dl element
+  while (dlElement.firstChild) {
+    dlElement.removeChild(dlElement.firstChild);
+  }
+
+  // Re-append elements in sorted order
+  pairs.forEach(pair => {
+    dlElement.appendChild(pair.dt);
+    pair.dds.forEach(dd => {
+      dlElement.appendChild(dd);
+    });
+  });
+
+  // Return the modified HTML
+  return dom.serialize();
+}
+
+/**
+ * Fixes broken definition list (dl) structures in the HTML output.
+ * Specifically, it addresses the issue where transcluded terms (tref tags) break
+ * out of the definition list, creating separate lists instead of a continuous one.
+ * 
+ * The strategy:
+ * 1. Find all definition lists (dl elements) in the document
+ * 2. Use the dl with class 'terms-and-definitions-list' as the main/target list
+ * 3. Process each subsequent node after the this main dl:
+ *    - If another dl is found, merge all its children into the main dl
+ *    - If a standalone dt is found, move it and its associated dd elements into the main dl
+ *    - Remove any empty paragraphs that might be breaking the list continuity
+ * 
+ * This ensures all terms appear in one continuous definition list,
+ * regardless of how they were originally rendered in the markdown.
+ * 
+ * @param {string} html - The HTML content to fix
+ * @returns {string} - The fixed HTML content with merged definition lists
+ */
+function fixDefinitionListStructure(html) {
+  const dom = new JSDOM(html);
+  const document = dom.window.document;
+
+  // Find all dl elements first
+  const allDls = Array.from(document.querySelectorAll('dl'));
+
+  // Then filter to find the one with the terms-and-definitions-list class
+  const dlElements = allDls.filter(dl => {
+    return dl?.classList?.contains('terms-and-definitions-list');
+  });
+
+  // Find any transcluded term dt elements anywhere in the document
+  const transcludedTerms = document.querySelectorAll('dt.transcluded-xref-term');
+
+  let mainDl = null;
+
+  // If we have an existing dl with the terms-and-definitions-list class, use it
+  if (dlElements.length > 0) {
+    mainDl = dlElements[0]; // Use the first one
+  }
+  // If we have transcluded terms but no main dl, we need to create one
+  else if (transcludedTerms.length > 0) {
+    // Create a new dl element with the right class
+    mainDl = document.createElement('dl');
+    mainDl.className = 'terms-and-definitions-list';
+
+    // Look for the marker
+    const marker = document.getElementById('terminology-section-start');
+
+    if (marker) {
+      // Insert the new dl right after the marker
+      if (marker.nextSibling) {
+        marker.parentNode.insertBefore(mainDl, marker.nextSibling);
+      } else {
+        marker.parentNode.appendChild(mainDl);
+      }
+    } else {
+      // Fallback to the original approach if marker isn't found
+      const firstTerm = transcludedTerms[0];
+      const insertPoint = firstTerm.parentNode;
+      insertPoint.parentNode.insertBefore(mainDl, insertPoint);
+    }
+  }
+
+  // Safety check - if we still don't have a mainDl, exit early to avoid null reference errors
+  if (!mainDl) {
+    return html; // Return the original HTML without modifications
+  }
+
+  /**
+   * Helper function to collect dt/dd pairs from a node
+   * @param {Node} startNode - The node to start collecting from 
+   * @returns {Array} - Array of elements that are part of the definition group
+   */
+  function collectDtDdGroup(startNode) {
+    const group = [];
+    let currentNode = startNode;
+    
+    // Collect the dt and all following dd elements
+    while (currentNode && (currentNode.tagName === 'DT' || currentNode.tagName === 'DD')) {
+      group.push(currentNode);
+      currentNode = currentNode.nextSibling;
+      
+      // Skip text nodes (whitespace) between elements
+      while (currentNode && currentNode.nodeType === 3 && !currentNode.textContent.trim()) {
+        currentNode = currentNode.nextSibling;
+      }
+    }
+    
+    return group;
+  }
+
+  // Process all transcluded terms and move them with their dd elements
+  transcludedTerms.forEach(dt => {
+    // Check if this dt is not already inside our main dl
+    if (dt.parentElement !== mainDl) {
+      // Collect the dt and its associated dd elements
+      const group = collectDtDdGroup(dt);
+      
+      // Move all elements in the group to the main dl
+      group.forEach(element => {
+        if (element.parentNode) {
+          const elementClone = element.cloneNode(true);
+          mainDl.appendChild(elementClone);
+          element.parentNode.removeChild(element);
+        }
+      });
+    }
+  });
+
+  // Remove any empty dt elements that may exist
+  const emptyDts = mainDl.querySelectorAll('dt:empty');
+  emptyDts.forEach(emptyDt => {
+    emptyDt.parentNode.removeChild(emptyDt);
+  });
+
+  // Process all subsequent content after the main dl
+  let currentNode = mainDl.nextSibling;
+
+  // Process all subsequent content
+  while (currentNode) {
+    // Save the next node before potentially modifying the DOM
+    const nextNode = currentNode.nextSibling;
+
+    // Handle different node types
+    if (currentNode.nodeType === 1) { // 1 = Element node
+      if (currentNode.tagName === 'DL') {
+        // Check if this is a reference list (contains dt elements with id="ref:...")
+        const hasRefIds = currentNode.innerHTML.includes('id="ref:') || 
+                          currentNode.classList.contains('reference-list');
+        
+        if (!hasRefIds) {
+          // Only move non-reference definition lists - move all its children to the main dl
+          while (currentNode.firstChild) {
+            mainDl.appendChild(currentNode.firstChild);
+          }
+          // Remove the now-empty dl element
+          currentNode.parentNode.removeChild(currentNode);
+        }
+        // If it's a reference list, leave it alone
+      }
+      else if (currentNode.tagName === 'DT') {
+        // Check if this dt has a ref: id (spec reference)
+        const hasRefId = currentNode.id?.startsWith('ref:');
+        
+        if (!hasRefId) {
+          // Collect the dt and its associated dd elements
+          const group = collectDtDdGroup(currentNode);
+          
+          // Move all elements in the group to the main dl
+          group.forEach(element => {
+            if (element.parentNode) {
+              const elementClone = element.cloneNode(true);
+              mainDl.appendChild(elementClone);
+              element.parentNode.removeChild(element);
+            }
+          });
+          
+          // Skip the nodes we just processed
+          let skipNodes = group.length - 1; // -1 because currentNode will be advanced anyway
+          while (skipNodes > 0 && nextNode) {
+            const nodeToSkip = nextNode;
+            currentNode = nextNode;
+            nextNode = nextNode.nextSibling;
+            skipNodes--;
+          }
+        }
+        // If it's a spec reference dt, leave it alone
+      }
+      else if (currentNode.tagName === 'DD') {
+        // Handle orphaned dd elements - move them to the main dl if they don't belong to a reference
+        const dtBefore = currentNode.previousSibling;
+        let hasAssociatedDt = false;
+        
+        // Check if there's a dt before this dd (walking backwards through siblings)
+        let checkNode = currentNode.previousSibling;
+        while (checkNode) {
+          // Skip text nodes
+          if (checkNode.nodeType === 3 && !checkNode.textContent.trim()) {
+            checkNode = checkNode.previousSibling;
+            continue;
+          }
+          
+          if (checkNode.tagName === 'DT') {
+            hasAssociatedDt = true;
+            break;
+          } else if (checkNode.tagName !== 'DD') {
+            // Found a non-dt, non-dd element, so this dd is orphaned
+            break;
+          }
+          
+          checkNode = checkNode.previousSibling;
+        }
+        
+        // If this dd doesn't have an associated dt in the same context, move it to main dl
+        if (!hasAssociatedDt) {
+          const ddClone = currentNode.cloneNode(true);
+          mainDl.appendChild(ddClone);
+          currentNode.parentNode.removeChild(currentNode);
+        }
+      }
+      else if (currentNode.tagName === 'P' &&
+        (!currentNode.textContent || currentNode.textContent.trim() === '')) {
+        // Remove empty paragraphs - these break the list structure
+        currentNode.parentNode.removeChild(currentNode);
+      }
+    }
+
+    // Move to the next node we saved earlier
+    currentNode = nextNode;
+  }
+
+  // Return the fixed HTML
+  return dom.serialize();
+}
+
+module.exports = {
+  sortDefinitionTermsInHtml,
+  fixDefinitionListStructure
+};

package/src/init.js

@@ -5,6 +5,9 @@ const initFlagPath = path.join(outputDir, 'init.flag');
 
 async function initialize() {
     try {
+        // Ensure the .cache directory exists
+        await fs.ensureDir(outputDir);
+        
         // Check if the init script has already run
         if (await fs.pathExists(initFlagPath)) {
             return;

package/src/install-from-boilerplate/boilerplate/.github/workflows/menu.yml

@@ -12,8 +12,7 @@ on:
           # - Edit specification
           - Render specification
           # - Develop specification
-          - Collect external references (cached)
-          - Collect external references (no cache)
+          - Collect external references
           - Convert to PDF
           - Freeze specification
           # - List references
@@ -74,20 +73,12 @@ jobs:
             # "Develop specification")
             #   node -e "require('spec-up-t')({ dev: true })"
             #   ;;
-            "Collect external references (cached)")
-              node --no-warnings -e "require('spec-up-t/src/collect-external-references.js').collectExternalReferences({cache: true})"
+            "Collect external references")
+              node --no-warnings -e "require('spec-up-t/src/collect-external-references.js').collectExternalReferences({ pat: process.env.MY_PAT })"
               git config --global user.email "actions@github.com"
               git config --global user.name "GitHub Actions"
               git add .
-              git commit -m "Collect external references (cached)" || echo "No changes to commit"
-              git push https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git HEAD:main
-              ;;
-            "Collect external references (no cache)")
-              node --no-warnings -e "require('spec-up-t/src/collect-external-references.js').collectExternalReferences({cache: false, pat: process.env.MY_PAT})"
-              git config --global user.email "actions@github.com"
-              git config --global user.name "GitHub Actions"
-              git add .
-              git commit -m "Collect external references (no cache)" || echo "No changes to commit"
+              git commit -m "Collect external references" || echo "No changes to commit"
               git push https://x-access-token:${{ secrets.GITHUB_TOKEN }}@github.com/${{ github.repository }}.git HEAD:main
               ;;
             "Convert to PDF")

package/src/install-from-boilerplate/boilerplate/spec/example-markup-in-markdown.md

@@ -159,7 +159,6 @@ You can even insert content within more complex blocks, like the JSON object bel
 | ♙   | ♙   | ♙   | ♙   |     | ♙   | ♙   | ♙   |
 | ♖   | ♘   | ♗   | ♕   | ♔   |     |     | ♖   |
 
-
 ### Sequence Diagrams
 
 <pre>

package/src/install-from-boilerplate/boilerplate/spec/terms-and-definitions-intro.md

@@ -1,5 +1 @@
-# Terms and Definitions Intro
-
-## Demo terms, definitions and external definitions
-
-A demo of terms and definitions, and references to external definitions.
+[//]: # (This file, named “terms-and-definitions-intro.md” is mandatory and should not be deleted.)

package/src/install-from-boilerplate/config-scripts-keys.js

@@ -2,9 +2,9 @@ const configScriptsKeys = {
     "edit": "node -e \"require('spec-up-t')()\"",
     "render": "node --no-warnings -e \"require('spec-up-t/index.js')({ nowatch: true })\"",
     "dev": "node -e \"require('spec-up-t')({ dev: true })\"",
-    "collectExternalReferencesCache": "node --no-warnings -e \"require('spec-up-t/src/collect-external-references.js').collectExternalReferences({cache: true})\"",
-    "collectExternalReferencesNoCache": "node --no-warnings -e \"require('spec-up-t/src/collect-external-references.js').collectExternalReferences({cache: false})\"",
+    "collectExternalReferences": "node --no-warnings -e \"require('spec-up-t/src/collect-external-references.js').collectExternalReferences()\"",
     "topdf": "node -e \"require('spec-up-t/src/create-pdf.js')\"",
+    "todocx": "node -e \"require('spec-up-t/src/create-docx.js')\"",
     "freeze": "node -e \"require('spec-up-t/src/freeze.js')\"",
     "references": "node -e \"require('spec-up-t/src/references.js')\"",
     "help": "cat ./node_modules/spec-up-t/src/install-from-boilerplate/help.txt",
@@ -20,9 +20,9 @@ const configOverwriteScriptsKeys = {
     "edit": true,
     "render": true,
     "dev": true,
-    "collectExternalReferencesCache": true,
-    "collectExternalReferencesNoCache": true,
+    "collectExternalReferences": true,
     "topdf": true,
+    "todocx": true,
     "freeze": true,
     "references": true,
     "help": true,

package/src/install-from-boilerplate/menu.sh

@@ -6,8 +6,8 @@ function handle_choice() {
         "Add content" "do_add_content"
         "Render specification" "do_render"
         "Export to PDF" "do_topdf"
-        "Collect external references (cache, faster)" "collect_external_references_cache"
-        "Collect external references (no cache, slower)" "collect_external_references_no_cache"
+        "Export to DOCX" "do_todocx"
+        "Collect external references" "collect_external_references"
         "Add, remove or view xref source" "do_add_remove_xref_source"
         "Configure" "do_configure"
         "Run health check" "do_health_check"
@@ -47,8 +47,8 @@ function display_intro() {
    [0] Add content
    [1] Render specification
    [2] Export to PDF
-   [3] Collect external references (cache, faster)
-   [4] Collect external references (no cache, slower)
+   [3] Export to DOCX
+   [4] Collect external references
    [5] Add, remove or view xref source
    [6] Configure
    [7] Run health check
@@ -74,8 +74,8 @@ function do_add_content() {
 
 function do_render() { clear; npm run render; }
 function do_topdf() { clear; npm run topdf; }
-function collect_external_references_cache() { clear; npm run collectExternalReferencesCache; }
-function collect_external_references_no_cache() { clear; npm run collectExternalReferencesNoCache; }
+function do_todocx() { clear; npm run todocx; }
+function collect_external_references() { clear; npm run collectExternalReferences; }
 function do_add_remove_xref_source() { clear; npm run addremovexrefsource; }
 function do_configure() { clear; npm run configure; }
 function do_health_check() { clear; npm run healthCheck; }

package/src/markdown-it-extensions.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { ESCAPED_PLACEHOLDER } = require('./escape-handler');
+
 /**
  * Configuration for custom template syntax [[example]] used throughout the markdown parsing
  * These constants define how template markers are identified and processed
@@ -64,6 +66,12 @@ module.exports = function (md, templates = {}) {
   md.inline.ruler.after('emphasis', 'templates', function templates_ruler(state, silent) {
     // Get the current parsing position
     var start = state.pos;
+
+    // Check if we're at an escaped placeholder - if so, skip processing
+    if (state.src.slice(start, start + ESCAPED_PLACEHOLDER.length) === ESCAPED_PLACEHOLDER) {
+      return false;
+    }
+
     // Check if we're at a template opening marker
     let prefix = state.src.slice(start, start + levels);
     if (prefix !== openString) return false;
@@ -195,24 +203,6 @@ module.exports = function (md, templates = {}) {
     }
   }
 
-  /**
-   * Helper function to add a 'last-dd' class to a dd token
-   * This enables special styling for the last definition description in a group
-   * 
-   * @param {Array} tokens - The token array containing the dd token
-   * @param {Number} ddIndex - The index of the dd_open token to modify
-   */
-  function addLastDdClass(tokens, ddIndex) {
-    if (ddIndex === -1) return;
-
-    const ddToken = tokens[ddIndex];
-    const classIndex = ddToken.attrIndex('class');
-    if (classIndex < 0) {
-      ddToken.attrPush(['class', 'last-dd']);
-    } else {
-      ddToken.attrs[classIndex][1] += ' last-dd';
-    }
-  }
 
   /**
    * Helper function to process definition description elements
@@ -224,23 +214,47 @@ module.exports = function (md, templates = {}) {
   function processLastDdElements(tokens, startIdx) {
     let lastDdIndex = -1; // Tracks the most recent dd_open token
 
+  }
+
+  /**
+   * Helper function to check if a definition list contains spec references
+   * Spec references have dt elements with id attributes starting with "ref:"
+   *
+   * @param {Array} tokens - The token array to search through
+   * @param {Number} startIdx - The index to start searching from (after dl_open)
+   * @return {Boolean} True if the dl contains spec references, false otherwise
+   */
+  function containsSpecReferences(tokens, startIdx) {
     for (let i = startIdx; i < tokens.length; i++) {
       if (tokens[i].type === 'dl_close') {
-        // Add class to the last <dd> before closing the entire <dl>
-        addLastDdClass(tokens, lastDdIndex);
-        break;
+        break; // Stop when we reach the end of this definition list
       }
-
-      if (tokens[i].type === 'dt_open' && !tokens[i].isEmpty) {
-        // When we find a non-empty dt, mark the previous dd as the last one in its group
-        addLastDdClass(tokens, lastDdIndex);
-        lastDdIndex = -1; // Reset for the next group
+      if (isDtRef(tokens[i])) {
+        return true;
       }
-
-      if (tokens[i].type === 'dd_open') {
-        lastDdIndex = i; // Track the most recently seen dd_open
+      if (isHtmlRef(tokens[i])) {
+        return true;
+      }
+      if (isInlineRef(tokens[i])) {
+        return true;
       }
     }
+    return false;
+  }
+
+  function isDtRef(token) {
+    if (token.type !== 'dt_open' || !token.attrs) return false;
+    return token.attrs.some(attr => attr[0] === 'id' && attr[1].startsWith('ref:'));
+  }
+
+  function isHtmlRef(token) {
+    if (token.type !== 'html_block' && token.type !== 'html_inline') return false;
+    return token.content && token.content.includes('id="ref:');
+  }
+
+  function isInlineRef(token) {
+    if (token.type !== 'inline') return false;
+    return token.content && token.content.includes('id="ref:');
   }
 
   /**
@@ -248,6 +262,10 @@ module.exports = function (md, templates = {}) {
    * Handles special styling for terminology sections and processes definition terms and descriptions
    * This function was refactored to reduce cognitive complexity by extracting helper functions
    * 
+   * IMPORTANT FIX: This function now checks if a <dl> already has a class attribute OR contains
+   * spec references (dt elements with id="ref:...") before adding the 'terms-and-definitions-list' 
+   * class. This prevents spec reference lists from being incorrectly classified as term definition lists.
+   * 
    * @param {Array} tokens - The token array being processed
    * @param {Number} idx - The index of the current token
    * @param {Object} options - Rendering options
@@ -259,8 +277,19 @@ module.exports = function (md, templates = {}) {
     const targetHtml = 'terminology-section-start';
     let targetIndex = findTargetIndex(tokens, targetHtml);
 
-    // Add class to the first <dl> only if it comes after the target HTML
-    if (targetIndex !== -1 && idx > targetIndex && !classAdded) {
+    // Check if the dl already has a class attribute (e.g., reference-list)
+    const existingClassIndex = tokens[idx].attrIndex('class');
+    const hasExistingClass = existingClassIndex >= 0;
+
+    // Check if this dl contains spec references (dt elements with id="ref:...")
+    const hasSpecReferences = containsSpecReferences(tokens, idx + 1);
+
+    // Only add terms-and-definitions-list class if:
+    // 1. It comes after the target HTML
+    // 2. We haven't added the class yet
+    // 3. The dl doesn't already have a class (to avoid overriding reference-list)
+    // 4. The dl doesn't contain spec references
+    if (targetIndex !== -1 && idx > targetIndex && !classAdded && !hasExistingClass && !hasSpecReferences) {
       tokens[idx].attrPush(['class', 'terms-and-definitions-list']);
       classAdded = true;
     }

package/src/references.js

@@ -47,25 +47,37 @@ async function fetchExternalSpecs(spec) {
   try {
     let results = await Promise.all(
       spec.external_specs.map(s => {
-        const url = s["gh_page"]; // Access the "gh_page" URL directly
-        return axios.get(url);
+        const url = s["gh_page"];
+        return axios.get(url).catch(error => ({ error, url }));
       })
     );
 
+    const failed = results.filter(r => r && r.error);
+    if (failed.length > 0) {
+      failed.forEach(f => {
+        const msg = f.error.response
+          ? `HTTP ${f.error.response.status} for ${f.url}`
+          : `Network error for ${f.url}: ${f.error.message}`;
+        console.error("❌ External spec fetch failed:", msg);
+      });
+    }
+
+    // Map results to objects keyed by external_spec if status is 200, otherwise null.
+    // This ensures only successful fetches are included, and failed ones are filtered out.
     results = results
       .map((r, index) =>
-        r.status === 200
+        r && r.status === 200
           ? { [spec.external_specs[index].external_spec]: r.data }
           : null
       )
-      .filter(r => r); // Remove null values
+      .filter(r => r); // Remove null values (failed fetches)
 
     return results.map(r =>
       createNewDLWithTerms(Object.keys(r)[0], Object.values(r)[0])
     );
   } catch (e) {
-    console.log("❌ " + e);
-    return []; // Return an empty array in case of errors
+    console.error("❌ Unexpected error in fetchExternalSpecs:", e);
+    return [];
   }
 }
 

package/templates/template.html

@@ -257,6 +257,8 @@
             <hr>
             <p class="ps-3 pe-3">External specifications:</p>
             ${externalSpecsList}
+            <hr>
+            <p id="w3c-state">W3C Recommendation, ${currentDate}</p>
         </div>
     </div>
 

package/test-default-definitions.js

@@ -0,0 +1,55 @@
+const { fixMarkdownFiles } = require('./src/fix-markdown-files');
+const fs = require('fs');
+const path = require('path');
+
+// Test cases for the default definition functionality
+function testDefaultDefinitions() {
+    console.log('Running tests for default definition functionality...');
+
+    const testContent = [
+        '[[def: test-term, test-term]]',
+        '',
+        '[[tref: another-term, another-term]]',
+        '',
+        '[[def: term-with-def, term-with-def]]',
+        '',
+        '~ This term already has a definition',
+        '',
+        '[[tref: final-term, final-term]]'
+    ].join('\n');
+
+    // Write test content to a temp file
+    const tempFile = './temp-test.md';
+    fs.writeFileSync(tempFile, testContent, 'utf8');
+
+    // Process the file
+    fixMarkdownFiles('.');
+
+    // Read and verify results
+    const result = fs.readFileSync(tempFile, 'utf8');
+    console.log('Test result:');
+    console.log(result);
+
+    // Clean up
+    fs.unlinkSync(tempFile);
+
+    // Verify expected content
+    const lines = result.split('\n');
+    let hasDefaultDefs = 0;
+    
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i] === '~ No local definition found.') {
+            hasDefaultDefs++;
+        }
+    }
+
+    console.log(`Found ${hasDefaultDefs} default definitions`);
+    
+    if (hasDefaultDefs === 3) { // Should be 3: test-term, another-term, final-term
+        console.log('✅ Test passed: All terms without definitions got default definitions');
+    } else {
+        console.log('❌ Test failed: Expected 3 default definitions');
+    }
+}
+
+testDefaultDefinitions();

package/test-edge-cases.md

@@ -0,0 +1,20 @@
+[[def: term1, term1]]
+
+~ No local definition found.
+
+[[def: term2, term2]]
+
+~ This term has a definition
+
+[[tref: term3, term3]]
+
+~ No local definition found.
+
+[[def: term4, term4]]
+
+~ This term also has a definition
+~ With multiple lines
+
+[[tref: term5, term5]]
+
+~ No local definition found.