@diplodoc/tabs-extension 3.10.8-transform5.2 → 3.10.8-transform5.3

package/build/plugin/index.js

@@ -582,9 +582,918 @@ var require_slugify = __commonJS({
   }
 });
 
+// node_modules/@diplodoc/directive/build/index.js
+var require_build = __commonJS({
+  "node_modules/@diplodoc/directive/build/index.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __commonJS2 = (cb, mod) => function __require() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var require_markdown_it_directive = __commonJS2({
+      "node_modules/markdown-it-directive/index.js"(exports22, module22) {
+        "use strict";
+        function isBlank(code) {
+          switch (code) {
+            case 9:
+            case 32:
+            case 10:
+              return true;
+          }
+          return false;
+        }
+        function skipBlanks(src, pos, max) {
+          for (; pos < max && isBlank(src.charCodeAt(pos)); ++pos) ;
+          return pos;
+        }
+        function skipBlanksBack(src, pos, min) {
+          for (; min < pos && isBlank(src.charCodeAt(pos - 1)); --pos) ;
+          return pos;
+        }
+        var DIRECTIVE_NAME_RE = /^[a-z][a-z0-9\-_]*/i;
+        var normalizeDirectiveName = (s) => s.toLowerCase().replace("_", "-");
+        function parseDirectiveName(src, pos, max) {
+          const oldPos = pos;
+          const rst = src.slice(pos, max).match(DIRECTIVE_NAME_RE);
+          if (rst === null) return null;
+          pos += rst[0].length;
+          return { pos, name: normalizeDirectiveName(src.slice(oldPos, pos)) };
+        }
+        function parseLinkDestinationLabel(md, src, pos, max) {
+          if (pos >= max) return null;
+          if (src.charCodeAt(pos) !== 40) return null;
+          const dests = [];
+          ++pos, pos = skipBlanks(src, pos, max);
+          for (; pos < max; pos = skipBlanks(src, pos, max)) {
+            if (src.charCodeAt(pos) === 41) {
+              ++pos;
+              return { pos, dests };
+            }
+            const c = src.charCodeAt(pos);
+            if (c === 34 || c === 39 || c === 40) {
+              const rst = md.helpers.parseLinkTitle(src, pos, max);
+              if (!rst.ok) return null;
+              pos = rst.pos;
+              dests.push(["string", rst.str]);
+            } else {
+              const rst = md.helpers.parseLinkDestination(src, pos, max);
+              if (!rst.ok) return null;
+              pos = rst.pos;
+              dests.push(["link", rst.str]);
+            }
+            if (pos >= max) return null;
+            const charBetween = src.charCodeAt(pos);
+            if (!isBlank(charBetween) && charBetween !== 41) return null;
+          }
+          return null;
+        }
+        var ATTR_NAME_RE = /^[a-z][a-z0-9\-_]*/;
+        function parseAttrName(src, pos, max) {
+          const oldPos = pos;
+          const rst = src.slice(pos, max).match(ATTR_NAME_RE);
+          if (rst === null) return null;
+          pos += rst[0].length;
+          return { pos, name: src.slice(oldPos, pos) };
+        }
+        var UNSURROUNDED_STRING_RE = /^[a-z0-9\-_]+/i;
+        function parseUnsurroundedName(src, pos, max) {
+          const oldPos = pos;
+          const rst = src.slice(pos, max).match(UNSURROUNDED_STRING_RE);
+          if (rst === null) return null;
+          pos += rst[0].length;
+          return { pos, name: src.slice(oldPos, pos) };
+        }
+        function parseAttrLabel(md, src, pos, max) {
+          if (pos >= max) return null;
+          if (src.charCodeAt(pos) !== 123) return null;
+          const attrs = /* @__PURE__ */ Object.create(null);
+          ++pos, pos = skipBlanks(src, pos, max);
+          for (; pos < max; pos = skipBlanks(src, pos, max)) {
+            if (src.charCodeAt(pos) === 125) {
+              ++pos;
+              for (const key in attrs) {
+                if (attrs[key].length === 1) attrs[key] = attrs[key][0];
+              }
+              return { pos, attrs: { ...attrs } };
+            }
+            const c = src.charCodeAt(pos);
+            if (c === 35) {
+              ++pos;
+              const rst = parseUnsurroundedName(src, pos, max);
+              if (rst === null) return null;
+              pos = rst.pos;
+              const key = "id", value = rst.name;
+              if (typeof attrs[key] === "undefined") {
+                attrs[key] = [value];
+              } else {
+                attrs[key].push(value);
+              }
+            } else if (c === 46) {
+              ++pos;
+              const rst = parseUnsurroundedName(src, pos, max);
+              if (rst === null) return null;
+              pos = rst.pos;
+              const key = "class", value = rst.name;
+              if (typeof attrs[key] === "undefined") {
+                attrs[key] = [value];
+              } else {
+                attrs[key].push(value);
+              }
+            } else {
+              let rst = parseAttrName(src, pos, max);
+              if (rst === null) return null;
+              const key = rst.name;
+              pos = rst.pos, pos = skipBlanks(src, pos, max);
+              if (pos >= max) return null;
+              if (src.charCodeAt(pos) !== 61) return null;
+              ++pos, pos = skipBlanks(src, pos, max);
+              if (pos >= max) return null;
+              let value;
+              const c2 = src.charCodeAt(pos);
+              if (c2 === 34 || c2 === 39) {
+                rst = md.helpers.parseLinkTitle(src, pos, max);
+                if (!rst.ok) return null;
+                value = rst.str;
+                pos = rst.pos;
+              } else {
+                rst = parseUnsurroundedName(src, pos, max);
+                if (rst === null) return null;
+                value = rst.name;
+                pos = rst.pos;
+              }
+              if (typeof attrs[key] === "undefined") {
+                attrs[key] = [value];
+              } else {
+                attrs[key].push(value);
+              }
+            }
+            if (pos >= max) return null;
+            const charBetween = src.charCodeAt(pos);
+            if (!isBlank(charBetween) && charBetween !== 125) return null;
+          }
+          return null;
+        }
+        function parseDirective(state, src, pos, max, allowSpaceBetween) {
+          const md = state.md;
+          const nameResult = parseDirectiveName(src, pos, max);
+          if (nameResult === null) return null;
+          const name = nameResult.name;
+          pos = nameResult.pos;
+          if (allowSpaceBetween) pos = skipBlanks(src, pos, max);
+          const labelStart = pos, labelEnd = md.helpers.parseLinkLabel(state, labelStart);
+          let content;
+          let contentStart, contentEnd;
+          if (labelEnd >= 0) {
+            content = src.slice(pos + 1, labelEnd);
+            pos = labelEnd + 1;
+            contentStart = labelStart + 1;
+            contentEnd = labelEnd;
+          }
+          if (allowSpaceBetween) pos = skipBlanks(src, pos, max);
+          const destsStart = pos;
+          const destsResult = parseLinkDestinationLabel(md, src, destsStart, max);
+          let dests;
+          if (destsResult !== null) {
+            dests = destsResult.dests;
+            pos = destsResult.pos;
+          } else if (typeof state.env.references !== "undefined") {
+            const destsEnd = md.helpers.parseLinkLabel(state, destsStart);
+            if (destsEnd >= 0) {
+              const refText = src.slice(destsStart + 1, destsEnd);
+              const ref = state.env.references[md.utils.normalizeReference(refText)];
+              if (ref) {
+                dests = [["link", ref.href], ["string", ref.title]];
+                pos = destsEnd + 1;
+              }
+            } else if (content !== void 0) {
+              const ref = state.env.references[md.utils.normalizeReference(content)];
+              if (ref) {
+                dests = [["link", ref.href], ["string", ref.title]];
+              }
+            }
+          }
+          if (allowSpaceBetween) pos = skipBlanks(src, pos, max);
+          const attrsResult = parseAttrLabel(md, src, pos, max);
+          let attrs;
+          if (attrsResult !== null) {
+            attrs = attrsResult.attrs;
+            pos = attrsResult.pos;
+          }
+          if (allowSpaceBetween) pos = skipBlanks(src, pos, max);
+          return { directiveName: name, content, dests, attrs, contentStart, contentEnd, pos };
+        }
+        function inlineDirectiveRule(state, silent) {
+          const md = state.md, src = state.src;
+          const max = state.posMax;
+          let pos = state.pos;
+          if (src.charCodeAt(pos) !== 58) return false;
+          ++pos;
+          const rst = parseDirective(state, src, pos, max, false);
+          if (rst === null) return false;
+          const { directiveName, content, dests, attrs, contentStart, contentEnd } = rst;
+          const handler = md.inlineDirectives[directiveName];
+          if (typeof handler === "undefined") return false;
+          pos = rst.pos;
+          if (!silent) {
+            const isValidContent = handler({
+              state,
+              content,
+              dests,
+              attrs,
+              contentStart,
+              contentEnd,
+              directiveStart: state.pos,
+              directiveEnd: pos
+            });
+            if (isValidContent === false) return false;
+          }
+          state.pos = pos;
+          return true;
+        }
+        function findNextLine(src, startLine, endLine, state) {
+          let line = startLine + 1;
+          let level = 1;
+          for (; line < endLine && level !== 0; ++line) {
+            const max = state.eMarks[line];
+            let pos = state.bMarks[line] + state.tShift[line];
+            let pos2 = state.skipChars(pos, 58);
+            let colonsCount = pos2 - pos;
+            if (colonsCount >= 3) {
+              pos2 = skipBlanks(src, pos2, max);
+              if (pos2 === max) {
+                --level;
+                continue;
+              }
+            }
+            if (colonsCount >= 3 && pos2 < max) {
+              ++level;
+            }
+          }
+          if (level !== 0) return -1;
+          return line;
+        }
+        function blockDirectiveRule(state, startLine, endLine, silent) {
+          const md = state.md, src = state.src;
+          const max = state.eMarks[startLine];
+          let pos = state.bMarks[startLine] + state.tShift[startLine];
+          if (pos + 3 > max || src.charCodeAt(pos) !== 58 || src.charCodeAt(pos + 1) !== 58) {
+            return false;
+          }
+          pos += 2;
+          let oneLine = false;
+          if (src.charCodeAt(pos) !== 58) {
+            oneLine = true;
+          } else {
+            pos = state.skipChars(
+              pos,
+              58
+              /* : */
+            );
+          }
+          pos = skipBlanks(src, pos, max);
+          const inlineState = new md.inline.State(src, md, state.env, []);
+          const rst = parseDirective(inlineState, src, pos, max, true);
+          if (rst === null) return false;
+          const { directiveName, content: inlineContent, dests, attrs, contentStart: inlineContentStart, contentEnd: inlineContentEnd } = rst;
+          const handler = md.blockDirectives[directiveName];
+          if (typeof handler === "undefined") return false;
+          pos = rst.pos;
+          const contentTitleStart = pos;
+          let posEnd = skipBlanksBack(src, max, pos);
+          let tmp = state.skipCharsBack(posEnd, 58, pos);
+          if (posEnd - tmp > 1) posEnd = tmp;
+          const contentTitleEnd = skipBlanksBack(src, posEnd, pos);
+          const contentTitle = src.slice(contentTitleStart, contentTitleEnd);
+          if (oneLine) {
+            if (!silent) {
+              const isValidContent = handler({
+                state,
+                contentTitle,
+                inlineContent,
+                dests,
+                attrs,
+                contentTitleStart,
+                contentTitleEnd,
+                inlineContentStart,
+                inlineContentEnd,
+                directiveStartLine: startLine,
+                directiveEndLine: startLine + 1
+              });
+              if (isValidContent === false) return false;
+            }
+            state.line = startLine + 1;
+            return true;
+          }
+          const nextLine = findNextLine(src, startLine, endLine, state);
+          if (nextLine === -1) return false;
+          const content = state.getLines(startLine + 1, nextLine - 1, state.sCount[startLine], true);
+          if (!silent) {
+            const isValidContent = handler({
+              state,
+              content,
+              contentTitle,
+              inlineContent,
+              dests,
+              attrs,
+              contentStartLine: startLine + 1,
+              contentEndLine: nextLine - 1,
+              contentTitleStart,
+              contentTitleEnd,
+              inlineContentStart,
+              inlineContentEnd,
+              directiveStartLine: startLine,
+              directiveEndLine: nextLine
+            });
+            if (isValidContent === false) return false;
+          }
+          state.line = nextLine;
+          return true;
+        }
+        function load(md) {
+          if (md.inlineDirectives) return;
+          md.inlineDirectives = {};
+          md.blockDirectives = {};
+          md.inline.ruler.push("inline_directive", inlineDirectiveRule);
+          md.block.ruler.before("heading", "block_directive", blockDirectiveRule);
+        }
+        module22.exports = load;
+      }
+    });
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      createBlockInlineToken: () => createBlockInlineToken,
+      directiveParser: () => directiveParser2,
+      disableBlockDirectives: () => disableBlockDirectives,
+      disableInlineDirectives: () => disableInlineDirectives,
+      enableBlockDirectives: () => enableBlockDirectives,
+      enableInlineDirectives: () => enableInlineDirectives,
+      registerContainerDirective: () => registerContainerDirective2,
+      registerInlineDirective: () => registerInlineDirective,
+      registerLeafBlockDirective: () => registerLeafBlockDirective,
+      tokenizeBlockContent: () => tokenizeBlockContent2,
+      tokenizeInlineContent: () => tokenizeInlineContent
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    var import_markdown_it_directive = __toESM2(require_markdown_it_directive());
+    function isRecord(value) {
+      return typeof value === "object" && value !== null;
+    }
+    function registry(host, key, create = false) {
+      let value = Reflect.get(host, key);
+      if (value === void 0 && create) {
+        value = {};
+        if (!Reflect.set(host, key, value)) {
+          throw new TypeError("Cannot create directive handler registry");
+        }
+      }
+      if (!isRecord(value)) {
+        throw new TypeError("Directive parser must be installed before registering directives");
+      }
+      return value;
+    }
+    function lookupHandler(host, key, name) {
+      const table = Reflect.get(host, key);
+      if (table === void 0) return void 0;
+      return registry(host, key)[name];
+    }
+    function assertHostState(state, Constructor) {
+      if (!(state instanceof Constructor)) {
+        throw new TypeError("Directive handler received a state from a different host");
+      }
+    }
+    function invokeHandler(handler, state, params) {
+      if (typeof handler !== "function") {
+        throw new TypeError("Invalid directive handler");
+      }
+      const result = Reflect.apply(handler, void 0, [state, params]);
+      if (result !== void 0 && typeof result !== "boolean") {
+        throw new TypeError("Invalid directive handler result");
+      }
+      return result;
+    }
+    function runtimeRules(ruler) {
+      const rules = Reflect.get(ruler, "__rules__");
+      if (!Array.isArray(rules)) {
+        throw new TypeError("Missing native block rules");
+      }
+      return rules.map((rule) => {
+        if (!isRecord(rule) || typeof rule.name !== "string" || typeof rule.enabled !== "boolean" || typeof rule.fn !== "function") {
+          throw new TypeError("Invalid native block rule");
+        }
+        return {
+          name: rule.name,
+          enabled: rule.enabled,
+          get fn() {
+            const fn = rule.fn;
+            if (typeof fn !== "function") throw new TypeError("Invalid native block rule");
+            return (state, start, end, silent) => {
+              const result = Reflect.apply(fn, void 0, [
+                state,
+                start,
+                end,
+                silent
+              ]);
+              if (typeof result !== "boolean")
+                throw new TypeError("Invalid block rule result");
+              return result;
+            };
+          },
+          set fn(fn) {
+            rule.fn = fn;
+          }
+        };
+      });
+    }
+    function assertScanner(value) {
+      if (!isRecord(value) || !isRecord(value.block) || typeof value.block.State !== "function" || typeof value.block.tokenize !== "function" || !isRecord(value.block.ruler)) {
+        throw new TypeError("Invalid native block scanner");
+      }
+      const ruler = value.block.ruler;
+      if (!["enableOnly", "before", "push"].every((key) => typeof ruler[key] === "function")) {
+        throw new TypeError("Invalid native block scanner ruler");
+      }
+    }
+    function assertBoundaryState(value) {
+      if (!isRecord(value) || typeof value.src !== "string" || typeof value.parentType !== "string" || typeof value.tight !== "boolean" || typeof value.skipChars !== "function" || !isRecord(value.md) || typeof value.md.constructor !== "function" || !isRecord(value.md.block) || !isRecord(value.md.block.ruler)) {
+        throw new TypeError("Invalid native block scanner state");
+      }
+      for (const key of ["bMarks", "eMarks", "tShift", "sCount", "bsCount"]) {
+        const field = value[key];
+        if (!Array.isArray(field) || !field.every((item) => typeof item === "number")) {
+          throw new TypeError(`Invalid native block scanner state: ${key}`);
+        }
+      }
+      if (value.ddIndent !== void 0 && typeof value.ddIndent !== "number") {
+        throw new TypeError("Invalid native block scanner state: ddIndent");
+      }
+      for (const key of ["line", "lineMax", "blkIndent", "listIndent", "level"]) {
+        if (typeof value[key] !== "number")
+          throw new TypeError(`Invalid native block scanner state: ${key}`);
+      }
+    }
+    function findClosingLine(state, startLine, endLine) {
+      const md = Reflect.construct(state.md.constructor, ["commonmark", state.md.options]);
+      assertScanner(md);
+      const hostRules = runtimeRules(state.md.block.ruler);
+      const enabled = new Set(hostRules.filter((rule) => rule.enabled).map((rule) => rule.name));
+      const nativeRules = runtimeRules(md.block.ruler);
+      md.block.ruler.enableOnly(
+        nativeRules.filter((rule) => enabled.has(rule.name)).map(({ name }) => name)
+      );
+      let closingLine = -1;
+      const scopes = [];
+      const marker = (scanState2, line, end, silent) => {
+        const pos = scanState2.bMarks[line] + scanState2.tShift[line];
+        const max = scanState2.eMarks[line];
+        const after = scanState2.skipChars(pos, 58);
+        if (after - pos < 3) {
+          return false;
+        }
+        if (silent) {
+          return true;
+        }
+        if (scanState2.sCount[line] < scanState2.blkIndent) {
+          return false;
+        }
+        const scope = scopes[scopes.length - 1];
+        if (/^[ \t]*$/.test(scanState2.src.slice(after, max))) {
+          if (scope.depth > 0 && --scope.depth === 0 && scope.root) {
+            closingLine = line;
+            scanState2.line = end;
+            return true;
+          }
+        } else {
+          scope.depth++;
+        }
+        scanState2.line = line + 1;
+        return true;
+      };
+      const paragraph = nativeRules.find(({ name }) => name === "paragraph");
+      if (paragraph) {
+        const paragraphRule = paragraph.fn;
+        paragraph.fn = (scanState2, begin, end, silent) => {
+          const matched = paragraphRule(scanState2, begin, end, silent);
+          if (matched && !silent) {
+            const next = scanState2.line;
+            for (let line = begin + 1; line < next; line++) {
+              marker(scanState2, line, end, false);
+              if (closingLine >= 0) {
+                return matched;
+              }
+            }
+            scanState2.line = next;
+          }
+          return matched;
+        };
+      }
+      const tokenize = md.block.tokenize;
+      md.block.tokenize = (scanState2, begin, end) => {
+        scopes.push({ depth: scopes.length ? 0 : 1, root: scopes.length === 0 });
+        try {
+          tokenize.call(md.block, scanState2, begin, end);
+        } finally {
+          scopes.pop();
+        }
+      };
+      md.block.ruler.before("heading", "directive_boundary", marker, {
+        alt: ["paragraph", "reference", "blockquote", "list"]
+      });
+      md.block.ruler.push("directive_boundary_fallback", (scanState2, line, _end, silent) => {
+        if (silent) {
+          return false;
+        }
+        scanState2.line = line + 1;
+        return true;
+      });
+      const scanState = Reflect.construct(md.block.State, [state.src, md, {}, []]);
+      assertBoundaryState(scanState);
+      Object.assign(scanState, {
+        bMarks: state.bMarks.slice(),
+        eMarks: state.eMarks.slice(),
+        tShift: state.tShift.slice(),
+        sCount: state.sCount.slice(),
+        bsCount: state.bsCount.slice(),
+        line: startLine + 1,
+        lineMax: endLine,
+        blkIndent: state.blkIndent,
+        listIndent: state.listIndent,
+        ddIndent: state.ddIndent,
+        parentType: state.parentType,
+        level: state.level,
+        tight: state.tight
+      });
+      md.block.tokenize(scanState, startLine + 1, endLine);
+      return closingLine;
+    }
+    function withBlockBoundary(rule) {
+      return (state, startLine, endLine, silent) => {
+        var _a;
+        const start = state.bMarks[startLine] + state.tShift[startLine];
+        if (state.src.slice(start, start + 3) !== ":::") {
+          return rule(state, startLine, endLine, silent);
+        }
+        const name = (_a = state.src.slice(start, state.eMarks[startLine]).match(/^:{3,}[ \t]*([a-z][a-z0-9_-]*)/i)) == null ? void 0 : _a[1];
+        const normalizedName = name == null ? void 0 : name.toLowerCase().replace("_", "-");
+        if (!normalizedName || !registry(state.md, "blockDirectives")[normalizedName]) {
+          return rule(state, startLine, endLine, silent);
+        }
+        const close = findClosingLine(state, startLine, endLine);
+        if (close < 0) {
+          return false;
+        }
+        const skipChars = state.skipChars;
+        const descriptor = Object.getOwnPropertyDescriptor(state, "skipChars");
+        const restore = () => {
+          if (descriptor) {
+            Object.defineProperty(state, "skipChars", descriptor);
+          } else {
+            Reflect.deleteProperty(state, "skipChars");
+          }
+        };
+        const hidden = /* @__PURE__ */ new Set();
+        for (let line = startLine + 1; line < close; line++) {
+          hidden.add(state.bMarks[line] + state.tShift[line]);
+        }
+        const closingPos = state.bMarks[close] + state.tShift[close];
+        state.skipChars = (pos, code) => {
+          if (code === 58) {
+            if (pos === closingPos) {
+              restore();
+            } else if (hidden.has(pos)) {
+              return pos;
+            }
+          }
+          return skipChars.call(state, pos, code);
+        };
+        try {
+          return rule(state, startLine, endLine, silent);
+        } finally {
+          restore();
+        }
+      };
+    }
+    var RULE = {
+      Inline: "inline_directive",
+      Block: "block_directive"
+    };
+    var CONTAINER_KEY = /* @__PURE__ */ Symbol();
+    var LEAF_BLOCK_KEY = /* @__PURE__ */ Symbol();
+    function enableInlineDirectives(md) {
+      md.inline.ruler.enable(RULE.Inline, true);
+    }
+    function disableInlineDirectives(md) {
+      md.inline.ruler.disable(RULE.Inline, true);
+    }
+    function enableBlockDirectives(md) {
+      md.block.ruler.enable(RULE.Block, true);
+    }
+    function disableBlockDirectives(md) {
+      md.block.ruler.disable(RULE.Block, true);
+    }
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    function tokenizeInlineContent(state, content) {
+      const oldPos = state.pos;
+      const oldPosMax = state.posMax;
+      state.pos = content.startPos;
+      state.posMax = content.endPos;
+      state.md.inline.tokenize(state);
+      state.pos = oldPos;
+      state.posMax = oldPosMax;
+    }
+    function tokenizeBlockContent2(state, content, parentType) {
+      const oldParent = state.parentType;
+      const oldLineMax = state.lineMax;
+      state.parentType = parentType != null ? parentType : "directive";
+      state.line = content.startLine;
+      state.lineMax = content.endLine;
+      state.md.block.tokenize(state, content.startLine, content.endLine);
+      state.lineMax = oldLineMax;
+      state.parentType = oldParent;
+    }
+    function createBlockInlineToken(state, { inlineContent, startLine }) {
+      const token = state.push("inline", "", 0);
+      token.children = [];
+      token.content = (inlineContent == null ? void 0 : inlineContent.raw) || "";
+      token.map = [startLine, startLine + 1];
+      return token;
+    }
+    function registerInlineDirective(md, name, handler) {
+      registry(md, "inlineDirectives")[name] = (args) => {
+        assertHostState(args.state, md.inline.State);
+        const params = buildInlineParams(args);
+        return handler(args.state, params);
+      };
+    }
+    function registerLeafBlockDirective(md, nameOrConfig, maybeHandler) {
+      const [name, handler] = isString(nameOrConfig) ? [nameOrConfig, maybeHandler] : [nameOrConfig.name, buildLeafBlockHandler(nameOrConfig)];
+      registry(md, LEAF_BLOCK_KEY, true);
+      registry(md, LEAF_BLOCK_KEY)[name] = handler;
+      registry(md, "blockDirectives")[name] = getBlockDefaultHandler(md, name);
+    }
+    function registerContainerDirective2(md, nameOrConfig, maybeHandler, options) {
+      const [name, handler] = isString(nameOrConfig) ? [nameOrConfig, maybeHandler] : [
+        nameOrConfig.name,
+        nameOrConfig.type === "code_block" ? buildCodeContainerHandler(nameOrConfig) : buildContainerHandler(nameOrConfig)
+      ];
+      const onConflict = isString(nameOrConfig) ? options == null ? void 0 : options.onConflict : nameOrConfig.onConflict;
+      const directives = registry(md, "blockDirectives");
+      if (onConflict === "error" && Object.prototype.hasOwnProperty.call(directives, name)) {
+        throw new Error(`Block directive already registered: ${name}`);
+      }
+      registry(md, CONTAINER_KEY, true);
+      registry(md, CONTAINER_KEY)[name] = handler;
+      registry(md, "blockDirectives")[name] = getBlockDefaultHandler(md, name);
+    }
+    function getBlockDefaultHandler(md, name) {
+      return (args) => {
+        assertHostState(args.state, md.block.State);
+        const containerHandler = lookupHandler(md, CONTAINER_KEY, name);
+        const leafBlockHandler = lookupHandler(md, LEAF_BLOCK_KEY, name);
+        if (isString(args.content)) {
+          if (containerHandler) {
+            return invokeHandler(containerHandler, args.state, buildContainerParams(args));
+          }
+        } else if (leafBlockHandler) {
+          return invokeHandler(leafBlockHandler, args.state, buildLeafBlockParams(args));
+        }
+        return false;
+      };
+    }
+    function buildLeafBlockHandler(config) {
+      return (state, params) => {
+        if (!config.match(params, state)) {
+          return false;
+        }
+        const { container } = config;
+        const token = state.push(container.token, container.tag, 0);
+        token.map = [params.startLine, params.endLine];
+        token.markup = "::" + config.name;
+        applyTokenFields(token, container, params, state.env);
+        return true;
+      };
+    }
+    function buildContainerHandler(config) {
+      return (state, params) => {
+        if (!params.content) {
+          return false;
+        }
+        if (config.inlineContent && !params.inlineContent && config.inlineContent.required !== false) {
+          return false;
+        }
+        if (!config.match(params, state)) {
+          return false;
+        }
+        const { container, inlineContent, content, contentTokenizer } = config;
+        let token = state.push(container.token + "_open", container.tag, 1);
+        token.map = [params.startLine, params.endLine];
+        token.markup = ":::" + config.name;
+        applyTokenFields(token, container, params, state.env);
+        if (inlineContent) {
+          token = state.push(inlineContent.token + "_open", inlineContent.tag, 1);
+          applyTokenFields(token, inlineContent, params, state.env);
+          token = createBlockInlineToken(state, params);
+          token = state.push(inlineContent.token + "_close", inlineContent.tag, -1);
+        }
+        if (content) {
+          token = state.push(content.token + "_open", content.tag, 1);
+          token.map = [params.startLine + 1, params.endLine - 1];
+          applyTokenFields(token, content, params, state.env);
+        }
+        if (contentTokenizer) {
+          contentTokenizer(state, params.content, params);
+        } else {
+          tokenizeBlockContent2(state, params.content, config.name + "-directive");
+        }
+        if (content) {
+          token = state.push(content.token + "_close", content.tag, -1);
+        }
+        token = state.push(container.token + "_close", container.tag, -1);
+        return true;
+      };
+    }
+    function buildCodeContainerHandler(config) {
+      return (state, params) => {
+        if (!params.content) {
+          return false;
+        }
+        if (!config.match(params, state)) {
+          return false;
+        }
+        const { name, container } = config;
+        const token = state.push(container.token, container.tag, 0);
+        token.map = [params.startLine, params.endLine];
+        token.content = params.content.raw;
+        token.markup = ":::";
+        token.info = name;
+        applyTokenFields(token, container, params, state.env);
+        return true;
+      };
+    }
+    function buildInlineParams(args) {
+      const params = {
+        startPos: args.directiveStart,
+        endPos: args.directiveEnd
+      };
+      if (args.attrs !== void 0) {
+        params.attrs = args.attrs;
+      }
+      if (args.dests !== void 0) {
+        params.dests = buildDests(args.dests);
+      }
+      if (args.content !== void 0) {
+        params.content = {
+          raw: args.content,
+          startPos: args.contentStart,
+          endPos: args.contentEnd
+        };
+      }
+      return params;
+    }
+    function buildLeafBlockParams(args) {
+      const params = {
+        startLine: args.directiveStartLine,
+        endLine: args.directiveEndLine
+      };
+      if (args.attrs !== void 0) {
+        params.attrs = args.attrs;
+      }
+      if (args.dests !== void 0) {
+        params.dests = buildDests(args.dests);
+      }
+      if (args.inlineContent !== void 0) {
+        params.inlineContent = {
+          raw: args.inlineContent,
+          startPos: args.inlineContentStart,
+          endPos: args.inlineContentEnd
+        };
+      }
+      if (args.contentTitle) {
+        params.contentTitle = {
+          raw: args.contentTitle,
+          startPos: args.contentTitleStart,
+          endPos: args.contentTitleEnd
+        };
+      }
+      return params;
+    }
+    function buildContainerParams(args) {
+      const params = buildLeafBlockParams(args);
+      return {
+        ...params,
+        content: {
+          raw: args.content,
+          startLine: args.contentStartLine,
+          endLine: args.contentEndLine
+        }
+      };
+    }
+    function buildDests(orig) {
+      var _a, _b;
+      const dests = { _original_dests: orig };
+      const link = (_a = orig.find((item) => item[0] === "link")) == null ? void 0 : _a[1];
+      const string = (_b = orig.find((item) => item[0] === "string")) == null ? void 0 : _b[1];
+      if (link !== void 0) {
+        dests.link = link;
+      }
+      if (string !== void 0) {
+        dests.string = string;
+      }
+      return dests;
+    }
+    function applyTokenFields(token, { attrs, meta }, params, env) {
+      if (attrs !== void 0) {
+        const value = isFunction(attrs) ? attrs(params, env) : attrs;
+        token.attrs = Object.entries(value);
+      }
+      if (meta !== void 0) {
+        const value = isFunction(meta) ? meta(params, env) : meta;
+        token.meta = value;
+      }
+    }
+    var BLOCK_LABELS_CONSTRAINED = /* @__PURE__ */ Symbol("block-labels-constrained");
+    function lineEnd(src, start, fallback) {
+      const lf = src.indexOf("\n", start);
+      const cr = src.indexOf("\r", start);
+      const ends = [lf, cr].filter((position) => position >= 0);
+      return ends.length ? Math.min(...ends) : fallback;
+    }
+    function constrainBlockDirectiveLabels(md) {
+      if (Reflect.get(md, BLOCK_LABELS_CONSTRAINED)) {
+        return;
+      }
+      const rule = runtimeRules(md.block.ruler).find(({ name }) => name === "block_directive");
+      if (!rule) {
+        return;
+      }
+      const blockDirectiveRule = withBlockBoundary(rule.fn);
+      if (!Reflect.set(md, BLOCK_LABELS_CONSTRAINED, true)) {
+        throw new TypeError("Cannot mark directive block labels as constrained");
+      }
+      rule.fn = (state, startLine, endLine, silent) => {
+        const parseLinkLabel = md.helpers.parseLinkLabel;
+        md.helpers.parseLinkLabel = (inlineState, start, disableNested) => {
+          if (inlineState.src.charCodeAt(start) !== 91) {
+            return -1;
+          }
+          const posMax = inlineState.posMax;
+          inlineState.posMax = Math.min(posMax, lineEnd(inlineState.src, start, posMax));
+          try {
+            return parseLinkLabel(inlineState, start, disableNested);
+          } finally {
+            inlineState.posMax = posMax;
+          }
+        };
+        try {
+          return blockDirectiveRule(state, startLine, endLine, silent);
+        } finally {
+          md.helpers.parseLinkLabel = parseLinkLabel;
+        }
+      };
+    }
+    var directiveParser2 = () => {
+      return (md) => {
+        Reflect.apply(import_markdown_it_directive.default, void 0, [md]);
+        constrainBlockDirectiveLabels(md);
+      };
+    };
+  }
+});
+
 // src/plugin/index.ts
 var index_exports = {};
 __export(index_exports, {
+  recognizeTabsBoundary: () => recognizeTabsBoundary,
   transform: () => transform
 });
 module.exports = __toCommonJS(index_exports);
@@ -615,6 +1524,13 @@ var TABS_ACCORDION_CLASSNAME = "yfm-tabs-accordion";
 var TABS_RADIO_CLASSNAME = "yfm-tabs-vertical";
 var VERTICAL_TAB_CLASSNAME = "yfm-vertical-tab";
 var TAB_DATA_VERTICAL_TAB = "data-diplodoc-vertical-tab";
+var TabsVariants = /* @__PURE__ */ ((TabsVariants2) => {
+  TabsVariants2["Regular"] = "regular";
+  TabsVariants2["Radio"] = "radio";
+  TabsVariants2["Dropdown"] = "dropdown";
+  TabsVariants2["Accordion"] = "accordion";
+  return TabsVariants2;
+})(TabsVariants || {});
 
 // src/plugin/utils/strings.ts
 function trim(target) {
@@ -1161,6 +2077,9 @@ function matchOpenToken(tokens, i) {
   }
   return tokens[i + 1].content.match(TAB_RE);
 }
+function defaultTabsGroup(generateID) {
+  return generateID(DEFAULT_TABS_GROUP_PREFIX.replace(/-$/, ""));
+}
 function props(content, generateID) {
   const clean = trim(content.replace("list tabs", ""));
   const props2 = clean.split(" ");
@@ -1170,10 +2089,9 @@ function props(content, generateID) {
     // DEFAULT_TABS_GROUP_PREFIX ends with '-', so strip it before passing to generateID
     // which appends '-N' itself. Result: 'defaultTabsGroup-1', 'defaultTabsGroup-2', …
     // TabsController checks group.startsWith(DEFAULT_TABS_GROUP_PREFIX) which still matches.
-    group: generateID(DEFAULT_TABS_GROUP_PREFIX.replace(/-$/, ""))
+    group: defaultTabsGroup(generateID)
   };
-  for (const prop of props2) {
-    const [key, value] = prop.split("=").map(trim);
+  visitProps(props2, (key, value) => {
     switch (key) {
       case "horizontal":
       case "radio":
@@ -1186,9 +2104,41 @@ function props(content, generateID) {
         break;
       default:
     }
-  }
+  });
   return result;
 }
+function visitProps(parts, visit) {
+  for (const prop of parts) {
+    const pieces = prop.split("=").map(trim);
+    visit(pieces[0], pieces[1], pieces);
+  }
+}
+function recognizeTabsBoundary(tokens, i) {
+  if (!tokens[i] || !tokens[i + 1]) return void 0;
+  const match = matchOpenToken(tokens, i);
+  const close = !match && matchCloseToken(tokens, i);
+  if (!match && !close) return void 0;
+  const map = tokens[i].map;
+  const common = { map: map ? [map[0], map[1]] : null, raw: tokens[i + 1].content };
+  if (close) return { kind: "close", ...common };
+  if (!match || match[0].startsWith("`") && match[0].endsWith("`")) return void 0;
+  if (tokens[i + 1].content.trim() !== match[0]) return { kind: "unsupported", ...common };
+  let variant = { present: false };
+  let group = { present: false };
+  let unsupported = false;
+  const parts = trim(match[0].replace("list tabs", "")).split(" ");
+  visitProps(parts, (key, value, pieces) => {
+    if ((!key || key === "{%" || key === "%}") && pieces.length === 1) return;
+    if (["horizontal", "radio", "dropdown", "accordion"].includes(key) && pieces.length === 1 && !variant.present) {
+      variant = { present: true, raw: key };
+    } else if (key === "group" && pieces.length === 2 && value && !group.present) {
+      group = { present: true, raw: value, value: unquote(value) };
+    } else {
+      unsupported = true;
+    }
+  });
+  return unsupported ? { kind: "unsupported", ...common } : { kind: "open", ...common, variant, group };
+}
 function tryToFindTabs(tokens, index) {
   var _a;
   const match = matchOpenToken(tokens, index);
@@ -1234,7 +2184,7 @@ function tryToFindTabs(tokens, index) {
     extraTokensAfterClose
   };
 }
-function findTabs(tokens, idx, closeTokenIdx, TokenConstructor) {
+function findTabs(tokens, idx, closeTokenIdx, TokenConstructor, end) {
   const tabs = [];
   let i = idx;
   let nestedLevel = -1;
@@ -1243,7 +2193,7 @@ function findTabs(tokens, idx, closeTokenIdx, TokenConstructor) {
     tokens: [],
     listItem: new TokenConstructor("list_item_open", "", 0)
   };
-  while (i < tokens.length) {
+  while (i < end) {
     const token = tokens[i];
     switch (token.type) {
       case "ordered_list_open":
@@ -1296,6 +2246,70 @@ function findTabs(tokens, idx, closeTokenIdx, TokenConstructor) {
   return tabs;
 }
 
+// src/plugin/directive.ts
+var import_directive = __toESM(require_build());
+var OPEN = "yfm_tabs_directive_open";
+var CLOSE = "yfm_tabs_directive_close";
+function parseParams(params) {
+  var _a, _b;
+  if (params.inlineContent || params.contentTitle || params.dests) {
+    return { reason: "Tabs directives do not support a title or destination" };
+  }
+  const attrs = (_a = params.attrs) != null ? _a : {};
+  for (const name of Object.keys(attrs)) {
+    if (name !== "variant" && name !== "group")
+      return { reason: `Unknown tabs attribute: ${name}` };
+    if (Array.isArray(attrs[name])) return { reason: `Repeated tabs attribute: ${name}` };
+  }
+  const rawVariant = (_b = attrs.variant) != null ? _b : "regular" /* Regular */;
+  const variant = Object.values(TabsVariants).find((candidate) => candidate === rawVariant);
+  if (!variant) {
+    return { reason: "Invalid tabs variant" };
+  }
+  const group = attrs.group;
+  if (group !== void 0 && (typeof group !== "string" || !group.trim())) {
+    return { reason: "Tabs group must be nonempty" };
+  }
+  return { variant, group };
+}
+function installTabsDirective(md, markers, onDiagnostic) {
+  (0, import_directive.directiveParser)()(md);
+  (0, import_directive.registerContainerDirective)(
+    md,
+    "tabs",
+    (state, params) => {
+      const parsed = parseParams(params);
+      if ("reason" in parsed) {
+        onDiagnostic == null ? void 0 : onDiagnostic({ line: params.startLine + 1, reason: parsed.reason });
+        return false;
+      }
+      const open = state.push(OPEN, "", 0);
+      open.map = [params.startLine, params.endLine];
+      (0, import_directive.tokenizeBlockContent)(state, params.content, "tabs-directive");
+      const close = state.push(CLOSE, "", 0);
+      close.map = [params.endLine - 1, params.endLine];
+      markers.set(open, { kind: "open", end: close, ...parsed });
+      markers.set(close, { kind: "close" });
+      return true;
+    },
+    { onConflict: "error" }
+  );
+}
+function validateTabsMarkers(tokens, markers) {
+  const expected = [];
+  for (const token of tokens) {
+    const marker = markers.get(token);
+    if (!marker && (token.type === OPEN || token.type === CLOSE)) {
+      throw new Error("Unowned tabs directive marker");
+    }
+    if ((marker == null ? void 0 : marker.kind) === "open") expected.push(marker.end);
+    else if ((marker == null ? void 0 : marker.kind) === "close" && expected.pop() !== token) {
+      throw new Error("Tabs directive opening marker is missing or crossed");
+    }
+  }
+  if (expected.length) throw new Error("Tabs directive closing marker is missing");
+}
+
 // src/plugin/transform.ts
 var defaultFeatures = {
   enabledVariants: {
@@ -1317,6 +2331,36 @@ function appendRuntimeMeta(env, runtimeJsPath, runtimeCssPath) {
   meta.script.push(runtimeJsPath);
   meta.style.push(runtimeCssPath);
 }
+function matchTabs(tokens, start, markers, legacy, generateID) {
+  var _a;
+  const marker = markers.get(tokens[start]);
+  if ((marker == null ? void 0 : marker.kind) === "close") throw new Error("Unexpected tabs directive closing marker");
+  if (marker) {
+    const close = tokens.findIndex((token, index) => index > start && token === marker.end);
+    if (close < 0) throw new Error("Tabs directive closing marker is missing");
+    const defaultGroup = defaultTabsGroup(generateID);
+    return {
+      close,
+      bodyStart: start + 1,
+      removeCount: close - start + 1,
+      end: close,
+      variant: marker.variant,
+      group: (_a = marker.group) != null ? _a : defaultGroup
+    };
+  }
+  if (!legacy) return { step: 1 };
+  const result = tryToFindTabs(tokens, start);
+  if ("step" in result) return result;
+  const parsed = props(result.content, generateID);
+  return {
+    close: result.closeTokenIndex,
+    bodyStart: start + 3,
+    removeCount: result.closeTokenIndex - start + 3 + result.extraTokensAfterClose,
+    end: tokens.length,
+    variant: parsed.variant,
+    group: parsed.group
+  };
+}
 function transform(options = {}) {
   const {
     runtimeJsPath = "_assets/tabs-extension.js",
@@ -1324,46 +2368,47 @@ function transform(options = {}) {
     containerClasses = "",
     bundle = true,
     features = defaultFeatures,
-    onBundle
+    onBundle,
+    directiveSyntax = "disabled",
+    onDiagnostic
   } = options;
-  return function tabs(md, options2) {
+  function installCore(md, options2, markers, legacy) {
     const { output = ".", generateID: externalGenerateID } = options2 || {};
     const generateID = externalGenerateID != null ? externalGenerateID : (0, import_utils6.createIDGeneratorByStrategy)("random");
     const plugin = (state) => {
       const { tokens } = state;
+      validateTabsMarkers(tokens, markers);
       const env = addHiddenProperty(state.env, "bundled", /* @__PURE__ */ new Set());
       const runId = String(++runsCounter);
       let i = 0;
       let tabsAreInserted = false;
       while (i < tokens.length) {
-        const result = tryToFindTabs(tokens, i);
-        if ("step" in result) {
-          i += result.step;
+        const match = matchTabs(tokens, i, markers, legacy, generateID);
+        if ("step" in match) {
+          i += match.step;
           continue;
         }
-        const { content, closeTokenIndex, extraTokensAfterClose } = result;
-        const parsedProps = props(content, generateID);
-        if (!features.enabledVariants[parsedProps.variant]) {
-          parsedProps.variant = "regular" /* Regular */;
-        }
-        const tabs2 = findTabs(state.tokens, i + 3, closeTokenIndex, state.Token);
-        if (tabs2.length > 0) {
-          const tabsTokens = generateTabsTokens(tabs2, state, {
+        const variant = features.enabledVariants[match.variant] ? match.variant : "regular" /* Regular */;
+        const tabs = findTabs(
+          state.tokens,
+          match.bodyStart,
+          match.close,
+          state.Token,
+          match.end
+        );
+        if (tabs.length > 0) {
+          const tabsTokens = generateTabsTokens(tabs, state, {
             containerClasses,
-            tabsGroup: parsedProps.group,
-            variant: parsedProps.variant,
+            tabsGroup: match.group,
+            variant,
             runId,
             generateID
           });
-          state.tokens.splice(
-            i,
-            closeTokenIndex - i + 3 + extraTokensAfterClose,
-            ...tabsTokens
-          );
+          state.tokens.splice(i, match.removeCount, ...tabsTokens);
           i++;
           tabsAreInserted = true;
         } else {
-          state.tokens.splice(i, closeTokenIndex - i + 3 + extraTokensAfterClose);
+          state.tokens.splice(i, match.removeCount);
         }
       }
       if (tabsAreInserted) {
@@ -1378,10 +2423,47 @@ function transform(options = {}) {
     } catch {
       md.core.ruler.push("tabs", plugin);
     }
-  };
+  }
+  function legacyPlugin(md, settings) {
+    installCore(md, settings, /* @__PURE__ */ new WeakMap(), true);
+  }
+  function directivePlugin(md, settings) {
+    const markers = /* @__PURE__ */ new WeakMap();
+    installTabsDirective(md, markers, onDiagnostic);
+    installCore(md, settings, markers, directiveSyntax === "enabled");
+  }
+  return directiveSyntax === "disabled" ? legacyPlugin : directivePlugin;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  recognizeTabsBoundary,
   transform
 });
+/*! Bundled license information:
+
+@diplodoc/directive/build/index.js:
+  (*!
+  MIT License
+  
+  Copyright (c) 2020 lookas
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+  *)
+*/
 //# sourceMappingURL=index.js.map