@diplodoc/tabs-extension 3.8.0 → 3.10.0

package/build/plugin/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -29,6 +32,444 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// node_modules/@diplodoc/utils/build/cjs/common/index.js
+var require_common = __commonJS({
+  "node_modules/@diplodoc/utils/build/cjs/common/index.js"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    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 __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports2 = {};
+    __export2(index_exports2, {
+      AttrsParser: () => AttrsParser,
+      createIDGenerator: () => createIDGenerator,
+      createIDGeneratorByStrategy: () => createIDGeneratorByStrategy2,
+      createLoadQueue: () => createLoadQueue,
+      getQueueStore: () => getQueueStore,
+      getScriptStore: () => getScriptStore,
+      isBrowser: () => isBrowser,
+      parseMdAttrs: () => parseMdAttrs
+    });
+    module2.exports = __toCommonJS2(index_exports2);
+    var _key, _pending, _isInsideQuotation, _didQuotationClosed, _currentKeyType, _selectors, _handlers, _a;
+    var AttrsParser = (_a = class {
+      constructor(value) {
+        __privateAdd(this, _key);
+        __privateAdd(this, _pending);
+        __privateAdd(this, _isInsideQuotation);
+        __privateAdd(this, _didQuotationClosed);
+        __privateAdd(this, _currentKeyType);
+        __privateAdd(this, _selectors);
+        __privateAdd(this, _handlers);
+        this.DELIMITER = "=";
+        this.SEPARATOR = " ";
+        this.QUOTATION = '"';
+        this.ALLOWED_CHARS = /[a-zA-Z0-9_\- {}.|/]/;
+        this.VALIDATION_CHARS = /[a-zA-Z0-9_\- {}.#="|/]/;
+        this.state = {};
+        __privateSet(this, _key, "");
+        __privateSet(this, _pending, "");
+        __privateSet(this, _isInsideQuotation, false);
+        __privateSet(this, _didQuotationClosed, false);
+        __privateSet(this, _selectors, {
+          id: /#/,
+          class: /\./,
+          attr: /[a-zA-Z-_]/
+        });
+        __privateSet(this, _handlers, Object.entries(__privateGet(this, _selectors)));
+        if (value) {
+          this.parse(value);
+        }
+      }
+      parse(target) {
+        const content = this.extract(target.trim());
+        if (!content) {
+          return {};
+        }
+        this.clear();
+        this.state = {};
+        for (const char of content) {
+          this.next(char);
+        }
+        this.next(this.SEPARATOR);
+        this.clear();
+        return this.state;
+      }
+      apply(target) {
+        const { attr: singleKeyAttrs = [], ...fullAttrs } = this.state;
+        for (const [property, values] of Object.entries(fullAttrs)) {
+          target.attrJoin(property, values.join(" "));
+        }
+        for (const attr of singleKeyAttrs) {
+          target.attrJoin(attr, "true");
+        }
+      }
+      extract(target) {
+        if (!target.startsWith("{")) {
+          return false;
+        }
+        let balance = 1;
+        for (let i = 1; i < target.length; i++) {
+          const char = target[i];
+          if (char === "}") {
+            balance--;
+          }
+          if (char === "{") {
+            balance++;
+          }
+          if (balance === 0) {
+            const contentInside = target.slice(1, i).trim();
+            return contentInside;
+          }
+          if (balance < 0) {
+            return false;
+          }
+          if (!this.VALIDATION_CHARS.test(char)) {
+            return false;
+          }
+        }
+        return false;
+      }
+      next(value) {
+        if (!__privateGet(this, _currentKeyType)) {
+          __privateSet(this, _currentKeyType, this.type(value));
+          if (__privateGet(this, _currentKeyType) === "attr") {
+            __privateSet(this, _pending, value);
+          }
+          return;
+        }
+        if (this.isSeparator(value)) {
+          if (!__privateGet(this, _pending)) {
+            if (!__privateGet(this, _isInsideQuotation)) {
+              this.append(__privateGet(this, _key), " ");
+              this.clear();
+              return;
+            }
+          }
+          if (!__privateGet(this, _key) && __privateGet(this, _pending)) {
+            this.append();
+            this.clear();
+            return;
+          }
+          if (__privateGet(this, _isInsideQuotation) && !__privateGet(this, _didQuotationClosed)) {
+            __privateSet(this, _pending, __privateGet(this, _pending) + value);
+            return;
+          }
+          if (__privateGet(this, _isInsideQuotation) && __privateGet(this, _didQuotationClosed)) {
+            this.append(__privateGet(this, _key), __privateGet(this, _pending));
+          }
+          if (!__privateGet(this, _isInsideQuotation) && !__privateGet(this, _didQuotationClosed)) {
+            this.append(__privateGet(this, _key), __privateGet(this, _pending));
+          }
+          this.clear();
+          return;
+        }
+        if (this.isAllowedChar(value)) {
+          __privateSet(this, _pending, __privateGet(this, _pending) + value);
+          return;
+        }
+        if (this.isQuotation(value)) {
+          if (__privateGet(this, _isInsideQuotation)) {
+            __privateSet(this, _didQuotationClosed, true);
+          } else {
+            __privateSet(this, _isInsideQuotation, true);
+          }
+        }
+        if (this.isDelimiter(value)) {
+          if (__privateGet(this, _key)) {
+            __privateSet(this, _pending, __privateGet(this, _pending) + value);
+            return;
+          }
+          __privateSet(this, _key, __privateGet(this, _pending));
+          __privateSet(this, _pending, "");
+        }
+      }
+      type(of) {
+        var _a2;
+        return (_a2 = __privateGet(this, _handlers).find(([_, regex]) => regex.test(of))) == null ? void 0 : _a2[0];
+      }
+      append(key = __privateGet(this, _currentKeyType), value = __privateGet(this, _pending)) {
+        if (!key) {
+          return;
+        }
+        if (!this.state[key]) {
+          this.state[key] = [];
+        }
+        this.state[key].push(value);
+      }
+      clear() {
+        __privateSet(this, _key, "");
+        __privateSet(this, _pending, "");
+        __privateSet(this, _isInsideQuotation, false);
+        __privateSet(this, _didQuotationClosed, false);
+        __privateSet(this, _currentKeyType, void 0);
+      }
+      isDelimiter(target) {
+        return target === this.DELIMITER;
+      }
+      isSeparator(target) {
+        return target === this.SEPARATOR;
+      }
+      isQuotation(target) {
+        return target === this.QUOTATION;
+      }
+      isAllowedChar(target) {
+        return this.ALLOWED_CHARS.test(target);
+      }
+    }, _key = new WeakMap(), _pending = new WeakMap(), _isInsideQuotation = new WeakMap(), _didQuotationClosed = new WeakMap(), _currentKeyType = new WeakMap(), _selectors = new WeakMap(), _handlers = new WeakMap(), _a);
+    function parseMdAttrs(md, src, pos, max) {
+      if (pos >= max) {
+        return null;
+      }
+      if (src.charCodeAt(pos) !== 123) {
+        return null;
+      }
+      const attrs = {};
+      ++pos;
+      pos = skipBlanks(src, pos, max);
+      for (; pos < max; pos = skipBlanks(src, pos, max)) {
+        if (src.charCodeAt(pos) === 125) {
+          ++pos;
+          return { pos, 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;
+          }
+          let value;
+          if (src.charCodeAt(pos) === 61) {
+            ++pos;
+            pos = skipBlanks(src, pos, max);
+            if (pos >= max) {
+              return null;
+            }
+            const c2 = src.charCodeAt(pos);
+            if (c2 === 34 || c2 === 39) {
+              const rst2 = md.helpers.parseLinkTitle(src, pos, max);
+              if (!rst2.ok) {
+                return null;
+              }
+              value = rst2.str;
+              pos = rst2.pos;
+            } else {
+              rst = parseUnsurroundedName(src, pos, max);
+              if (rst === null) {
+                return null;
+              }
+              value = rst.name;
+              pos = rst.pos;
+            }
+          } else {
+            if (isBlank(src.charCodeAt(pos - 1))) {
+              --pos;
+            }
+            value = "";
+          }
+          if (typeof value !== "undefined") {
+            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 isBlank(code) {
+        return md.utils.isSpace(code) || code === 10;
+      }
+      function skipBlanks(src2, pos2, max2) {
+        for (; pos2 < max2; pos2++) {
+          const code = src2.charCodeAt(pos2);
+          if (!isBlank(code)) {
+            break;
+          }
+        }
+        return pos2;
+      }
+    }
+    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) };
+    }
+    var isBrowser = () => {
+      return typeof window !== "undefined" && typeof window.document !== "undefined";
+    };
+    var QUEUES_SYMBOL = /* @__PURE__ */ Symbol.for("extension-load-queues");
+    var SINGLE_QUEUE_SYMBOL = /* @__PURE__ */ Symbol.for("single-queue");
+    var getScriptStore = (storeKey) => {
+      if (isBrowser()) {
+        if (!window[storeKey]) {
+          window[storeKey] = [];
+        } else if (!Array.isArray(window[storeKey])) {
+          throw new Error(`Expected window[${String(storeKey)}] to be an array`);
+        }
+        return window[storeKey];
+      } else {
+        throw new Error("Cannot initialize QueueStore in a non-browser environment.");
+      }
+    };
+    var ensureQueuesSymbolInitialized = () => {
+      if (isBrowser()) {
+        if (typeof window[QUEUES_SYMBOL] !== "object" || window[QUEUES_SYMBOL] === null) {
+          window[QUEUES_SYMBOL] = {};
+        }
+      } else {
+        throw new Error("Cannot initialize QueueStore in a non-browser environment.");
+      }
+    };
+    var getQueueStore = (queueKey) => {
+      var _a2;
+      ensureQueuesSymbolInitialized();
+      return ((_a2 = window[QUEUES_SYMBOL]) == null ? void 0 : _a2[queueKey]) || false;
+    };
+    var createHandleQueueCreated = (queueKey) => {
+      ensureQueuesSymbolInitialized();
+      return (created) => {
+        window[QUEUES_SYMBOL][queueKey] = created;
+      };
+    };
+    var createLoadQueue = ({
+      store,
+      createController,
+      queueKey = SINGLE_QUEUE_SYMBOL,
+      isQueueCreated = getQueueStore(queueKey),
+      onQueueCreated = createHandleQueueCreated(queueKey)
+    }) => {
+      if (!store || isQueueCreated) {
+        return;
+      }
+      onQueueCreated(true);
+      const controller = createController();
+      const queue = store.splice(0, store.length);
+      store.push = function(...args) {
+        args.forEach((callback) => {
+          queue.push(callback);
+          unqueue();
+        });
+        return queue.length;
+      };
+      let processing = false;
+      function unqueue() {
+        if (!processing) {
+          next();
+        }
+      }
+      async function next() {
+        processing = true;
+        const callback = queue.shift();
+        if (callback) {
+          await callback(controller);
+          return next();
+        }
+        processing = false;
+      }
+      unqueue();
+    };
+    function createIDGenerator() {
+      const counters = /* @__PURE__ */ new Map();
+      return function generateID(prefix) {
+        if (!prefix) {
+          return Math.random().toString(36).substr(2, 8);
+        }
+        counters.set(prefix, (counters.get(prefix) || 0) + 1);
+        return `${prefix}-${counters.get(prefix)}`;
+      };
+    }
+    function createIDGeneratorByStrategy2(strategy = "random") {
+      switch (strategy) {
+        case "deterministic":
+          return createIDGenerator();
+        case "constant":
+          return () => "1";
+        case "random":
+        default:
+          return (prefix) => {
+            if (!prefix) {
+              return Math.random().toString(36).substr(2, 8);
+            }
+            return `${prefix}-${Math.random().toString(36).substr(2, 8)}`;
+          };
+      }
+    }
+  }
+});
 
 // node_modules/github-slugger/regex.js
 var require_regex = __commonJS({
@@ -74,11 +515,14 @@ var require_github_slugger = __commonJS({
 });
 
 // src/plugin/index.ts
-var plugin_exports = {};
-__export(plugin_exports, {
+var index_exports = {};
+__export(index_exports, {
   transform: () => transform
 });
-module.exports = __toCommonJS(plugin_exports);
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin/transform.ts
+var import_utils6 = __toESM(require_common());
 
 // src/common.ts
 var TAB_RE = /`?{% list tabs .*?%}`?/;
@@ -103,13 +547,8 @@ 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 GLOBAL_SYMBOL = Symbol.for("diplodocTabs");
 
 // src/plugin/utils/strings.ts
-function generateID() {
-  const id = Math.random().toString(36).substr(2, 8);
-  return id.substring(id.length - 8);
-}
 function trim(target) {
   return target.trim();
 }
@@ -162,6 +601,17 @@ function getRawId(tab) {
   const { customAnchor, name } = parseName(tab.name);
   return customAnchor || name;
 }
+function getContentMap(tokens) {
+  let firstMap = null;
+  let lastMap = null;
+  tokens.forEach(({ map }) => {
+    if (map) {
+      firstMap = firstMap != null ? firstMap : map;
+      lastMap = map;
+    }
+  });
+  return firstMap && lastMap ? [firstMap[0], lastMap[1]] : null;
+}
 
 // src/plugin/utils/files.ts
 var PATH_TO_RUNTIME = "../runtime";
@@ -205,7 +655,7 @@ function addHiddenProperty(box, field, value) {
 }
 
 // src/plugin/variants/regular.ts
-var regular = (tabs, state, { containerClasses, tabsGroup, runId, variant: orientation }) => {
+var regular = (tabs, state, { containerClasses, tabsGroup, runId, variant: orientation, generateID }) => {
   var _a, _b;
   const tabsTokens = [];
   const tabListTokens = [];
@@ -260,12 +710,13 @@ var regular = (tabs, state, { containerClasses, tabsGroup, runId, variant: orien
     const didTabHasActiveAttr = isTabSelected(tab);
     const isTabActive = hasDefaultOpenTab ? didTabHasActiveAttr : i === 0;
     tab.name = getName(tab);
-    const tabPanelId = generateID();
+    const tabPanelId = generateID("regular");
     verticalTabInput.block = true;
     verticalTabInput.attrJoin("class", "radio");
     verticalTabInput.attrSet("type", "radio");
     tabOpen.map = tabs[i].listItem.map;
     tabOpen.markup = tabs[i].listItem.markup;
+    tabPanelOpen.map = getContentMap(tabs[i].tokens);
     tabText.content = tabs[i].name;
     tabInline.children = [tabText];
     tabOpen.block = true;
@@ -327,7 +778,7 @@ var regular = (tabs, state, { containerClasses, tabsGroup, runId, variant: orien
 };
 
 // src/plugin/variants/radio.ts
-var radio = (tabs, state, { containerClasses, tabsGroup, runId }) => {
+var radio = (tabs, state, { containerClasses, tabsGroup, runId, generateID }) => {
   var _a, _b;
   const tabsTokens = [];
   const tabsOpen = new state.Token("tabs_open", "div", 1);
@@ -372,12 +823,13 @@ var radio = (tabs, state, { containerClasses, tabsGroup, runId }) => {
     const tabKey = getTabKey(tab);
     const didTabHasActiveAttr = isTabSelected(tab);
     tab.name = getName(tab);
-    const tabPanelId = generateID();
+    const tabPanelId = generateID("radio");
     verticalTabInput.block = true;
     verticalTabInput.attrJoin("class", "radio");
     verticalTabInput.attrSet("type", "radio");
     tabOpen.map = tabs[i].listItem.map;
     tabOpen.markup = tabs[i].listItem.markup;
+    tabPanelOpen.map = getContentMap(tabs[i].tokens);
     tabText.content = tabs[i].name;
     tabInline.children = [tabText];
     tabOpen.block = true;
@@ -421,7 +873,7 @@ var radio = (tabs, state, { containerClasses, tabsGroup, runId }) => {
 };
 
 // src/plugin/variants/dropdown.ts
-var dropdown = (tabs, state, { containerClasses, tabsGroup, runId }) => {
+var dropdown = (tabs, state, { containerClasses, tabsGroup, runId, generateID }) => {
   var _a, _b;
   const dropdownTokens = [];
   const dropdownOpen = new state.Token("dropdown_open", "div", 1);
@@ -497,7 +949,8 @@ var dropdown = (tabs, state, { containerClasses, tabsGroup, runId }) => {
     const tabId = getTabId(tab, { runId });
     const didTabHasActiveAttr = isTabSelected(tab);
     tab.name = getName(tab);
-    const tabPanelId = generateID();
+    const tabPanelId = generateID("dropdown");
+    tabPanelOpen.map = getContentMap(tabs[i].tokens);
     tabPanelOpen.block = true;
     tabPanelClose.block = true;
     tabPanelOpen.attrSet("id", tabPanelId);
@@ -515,7 +968,7 @@ var dropdown = (tabs, state, { containerClasses, tabsGroup, runId }) => {
 };
 
 // src/plugin/variants/accordion.ts
-var accordion = (tabs, state, { containerClasses, tabsGroup, runId }) => {
+var accordion = (tabs, state, { containerClasses, tabsGroup, runId, generateID }) => {
   var _a, _b;
   const tabsTokens = [];
   const tabsOpen = new state.Token("tabs_open", "div", 1);
@@ -557,9 +1010,10 @@ var accordion = (tabs, state, { containerClasses, tabsGroup, runId }) => {
     const tabKey = getTabKey(tab);
     const didTabHasActiveAttr = isTabSelected(tab);
     tab.name = getName(tab);
-    const tabPanelId = generateID();
+    const tabPanelId = generateID("accordion");
     tabOpen.map = tabs[i].listItem.map;
     tabOpen.markup = tabs[i].listItem.markup;
+    tabPanelOpen.map = getContentMap(tabs[i].tokens);
     tabText.content = tabs[i].name;
     tabInline.children = [tabText];
     tabOpen.block = true;
@@ -630,15 +1084,21 @@ function matchCloseToken(tokens, i) {
   return tokens[i].type === "paragraph_open" && tokens[i + 1].type === "inline" && tokens[i + 1].content.trim() === "{% endlist %}";
 }
 function matchOpenToken(tokens, i) {
-  return tokens[i].type === "paragraph_open" && tokens[i + 1].type === "inline" && tokens[i + 1].content.match(TAB_RE);
+  if (tokens[i].type !== "paragraph_open" || tokens[i + 1].type !== "inline") {
+    return null;
+  }
+  return tokens[i + 1].content.match(TAB_RE);
 }
-function props(content) {
+function props(content, generateID) {
   const clean = trim(content.replace("list tabs", ""));
   const props2 = clean.split(" ");
   const result = {
     content: clean,
     variant: "regular" /* Regular */,
-    group: `${DEFAULT_TABS_GROUP_PREFIX}${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(/-$/, ""))
   };
   for (const prop of props2) {
     const [key, value] = prop.split("=").map(trim);
@@ -781,7 +1241,8 @@ function transform({
   features = defaultFeatures
 } = {}) {
   return function tabs(md, options) {
-    const { output = "." } = options || {};
+    const { output = ".", generateID: externalGenerateID } = options || {};
+    const generateID = externalGenerateID != null ? externalGenerateID : (0, import_utils6.createIDGeneratorByStrategy)("random");
     const plugin = (state) => {
       const { env, tokens } = state;
       const runId = String(++runsCounter);
@@ -795,7 +1256,7 @@ function transform({
           continue;
         }
         const { content, closeTokenIndex, extraTokensAfterClose } = result;
-        const parsedProps = props(content);
+        const parsedProps = props(content, generateID);
         if (!features.enabledVariants[parsedProps.variant]) {
           parsedProps.variant = "regular" /* Regular */;
         }
@@ -805,7 +1266,8 @@ function transform({
             containerClasses,
             tabsGroup: parsedProps.group,
             variant: parsedProps.variant,
-            runId
+            runId,
+            generateID
           });
           state.tokens.splice(
             i,
@@ -831,7 +1293,7 @@ function transform({
     };
     try {
       md.core.ruler.before("curly_attributes", "tabs", plugin);
-    } catch (e) {
+    } catch {
       md.core.ruler.push("tabs", plugin);
     }
   };