ktg-plugin-marketplace/plugins/voyage/playground/lib/markdown-it-front-matter.min.js

// vendored by scripts/vendor-playground-libs.mjs — DO NOT EDIT
// global: markdownitFrontMatter
(function (root, factory) {
  var __mod = { exports: {} };
  (function (module, exports) {
    // Process front matter and pass to cb
    'use strict';
    
    module.exports = function front_matter_plugin(md, cb) {
      var min_markers = 3,
          marker_str  = '-',
          marker_char = marker_str.charCodeAt(0),
          marker_len  = marker_str.length;
    
      function frontMatter(state, startLine, endLine, silent) {
        var pos,
            nextLine,
            marker_count,
            token,
            old_parent,
            old_line_max,
            start_content,
            auto_closed = false,
            start = state.bMarks[startLine] + state.tShift[startLine],
            max = state.eMarks[startLine];
    
        // Check out the first character of the first line quickly,
        // this should filter out non-front matter
        if (startLine !== 0 || marker_char !== state.src.charCodeAt(0)) {
          return false;
        }
    
        // Check out the rest of the marker string
        // while pos <= 3
        for (pos = start + 1; pos <= max; pos++) {
          if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
            start_content = pos + 1;
            break;
          }
        }
    
        marker_count = Math.floor((pos - start) / marker_len);
    
        if (marker_count < min_markers) {
          return false;
        }
        pos -= (pos - start) % marker_len;
    
        // Since start is found, we can report success here in validation mode
        if (silent) {
          return true;
        }
    
        // Search for the end of the block
        nextLine = startLine;
    
        for (;;) {
          nextLine++;
          if (nextLine >= endLine) {
            // unclosed block should be autoclosed by end of document.
            // also block seems to be autoclosed by end of parent
            break;
          }
    
          if (state.src.slice(start, max) === '...') {
            break;
          }
    
          start = state.bMarks[nextLine] + state.tShift[nextLine];
          max = state.eMarks[nextLine];
    
          if (start < max && state.sCount[nextLine] < state.blkIndent) {
            // non-empty line with negative indent should stop the list:
            // - ```
            //  test
            break;
          }
    
          if (marker_char !== state.src.charCodeAt(start)) {
            continue;
          }
    
          if (state.sCount[nextLine] - state.blkIndent >= 4) {
            // closing fence should be indented less than 4 spaces
            continue;
          }
    
          for (pos = start + 1; pos <= max; pos++) {
            if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
              break;
            }
          }
    
          // closing code fence must be at least as long as the opening one
          if (Math.floor((pos - start) / marker_len) < marker_count) {
            continue;
          }
    
          // make sure tail has spaces only
          pos -= (pos - start) % marker_len;
          pos = state.skipSpaces(pos);
    
          if (pos < max) {
            continue;
          }
    
          // found!
          auto_closed = true;
          break;
        }
    
        old_parent = state.parentType;
        old_line_max = state.lineMax;
        state.parentType = 'container';
    
        // this will prevent lazy continuations from ever going past our end marker
        state.lineMax = nextLine;
    
        token        = state.push('front_matter', null, 0);
        token.hidden = true;
        token.markup = state.src.slice(startLine, pos);
        token.block  = true;
        token.map    = [ startLine, nextLine + (auto_closed ? 1 : 0) ];
        token.meta   = state.src.slice(start_content, start - 1);
    
        state.parentType = old_parent;
        state.lineMax = old_line_max;
        state.line = nextLine + (auto_closed ? 1 : 0);
    
        cb(token.meta);
    
        return true;
      }
    
      md.block.ruler.before(
        'table',
        'front_matter',
        frontMatter,
        {
          alt: [
            'paragraph',
            'reference',
            'blockquote',
            'list' 
          ]
        }
      );
    };
    
  })(__mod, __mod.exports);
  root["markdownitFrontMatter"] = __mod.exports;
})(typeof window !== 'undefined' ? window : globalThis);