@diplodoc/tabs-extension 3.10.8-transform5.4 → 4.0.0-beta.1

package/build/plugin/index.js

@@ -582,914 +582,6 @@ 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, {
@@ -2277,7 +1369,7 @@ function findTabs(tokens, idx, closeTokenIdx, TokenConstructor, end, titleTokens
 }
 
 // src/plugin/directive.ts
-var import_directive = __toESM(require_build());
+var import_directive = require("@diplodoc/directive");
 var OPEN = "yfm_tabs_directive_open";
 var CLOSE = "yfm_tabs_directive_close";
 function parseParams(params) {
@@ -2492,31 +1584,4 @@ function transform(options = {}) {
   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