@storybook/addon-docs 9.2.0-alpha.3 → 10.0.0-beta.1

package/dist/_browser-chunks/chunk-TQ5Q4DDG.js

@@ -0,0 +1,846 @@
+import {
+  __export,
+  __name
+} from "./chunk-MM7DTO55.js";
+
+// ../../node_modules/tocbot/index.js
+var tocbot_exports = {};
+__export(tocbot_exports, {
+  default: () => tocbot_default,
+  destroy: () => destroy,
+  init: () => init,
+  refresh: () => refresh
+});
+
+// ../../node_modules/tocbot/src/js/build-html.js
+function build_html_default(options) {
+  const forEach = [].forEach;
+  const some = [].some;
+  const body = typeof window !== "undefined" && document.body;
+  const SPACE_CHAR = " ";
+  let tocElement;
+  let currentlyHighlighting = true;
+  let eventCount = 0;
+  function createEl(d, container) {
+    const link = container.appendChild(createLink(d));
+    if (d.children.length) {
+      const list = createList(d.isCollapsed);
+      d.children.forEach((child) => {
+        createEl(child, list);
+      });
+      link.appendChild(list);
+    }
+  }
+  __name(createEl, "createEl");
+  function render(parent, data) {
+    const collapsed = false;
+    const container = createList(collapsed);
+    data.forEach((d) => {
+      createEl(d, container);
+    });
+    tocElement = parent || tocElement;
+    if (tocElement === null) {
+      return;
+    }
+    if (tocElement.firstChild) {
+      tocElement.removeChild(tocElement.firstChild);
+    }
+    if (data.length === 0) {
+      return tocElement;
+    }
+    return tocElement.appendChild(container);
+  }
+  __name(render, "render");
+  function createLink(data) {
+    const item = document.createElement("li");
+    const a = document.createElement("a");
+    if (options.listItemClass) {
+      item.setAttribute("class", options.listItemClass);
+    }
+    if (options.onClick) {
+      a.onclick = options.onClick;
+    }
+    if (options.includeTitleTags) {
+      a.setAttribute("title", data.textContent);
+    }
+    if (options.includeHtml && data.childNodes.length) {
+      forEach.call(data.childNodes, (node) => {
+        a.appendChild(node.cloneNode(true));
+      });
+    } else {
+      a.textContent = data.textContent;
+    }
+    a.setAttribute("href", `${options.basePath}#${data.id}`);
+    a.setAttribute(
+      "class",
+      `${options.linkClass + SPACE_CHAR}node-name--${data.nodeName}${SPACE_CHAR}${options.extraLinkClasses}`
+    );
+    item.appendChild(a);
+    return item;
+  }
+  __name(createLink, "createLink");
+  function createList(isCollapsed) {
+    const listElement = options.orderedList ? "ol" : "ul";
+    const list = document.createElement(listElement);
+    let classes = options.listClass + SPACE_CHAR + options.extraListClasses;
+    if (isCollapsed) {
+      classes = classes + SPACE_CHAR + options.collapsibleClass;
+      classes = classes + SPACE_CHAR + options.isCollapsedClass;
+    }
+    list.setAttribute("class", classes);
+    return list;
+  }
+  __name(createList, "createList");
+  function updateFixedSidebarClass() {
+    const scrollTop = getScrollTop();
+    const posFixedEl = document.querySelector(options.positionFixedSelector);
+    if (options.fixedSidebarOffset === "auto") {
+      options.fixedSidebarOffset = tocElement.offsetTop;
+    }
+    if (scrollTop > options.fixedSidebarOffset) {
+      if (posFixedEl.className.indexOf(options.positionFixedClass) === -1) {
+        posFixedEl.className += SPACE_CHAR + options.positionFixedClass;
+      }
+    } else {
+      posFixedEl.className = posFixedEl.className.replace(
+        SPACE_CHAR + options.positionFixedClass,
+        ""
+      );
+    }
+  }
+  __name(updateFixedSidebarClass, "updateFixedSidebarClass");
+  function getHeadingTopPos(obj) {
+    let position = 0;
+    if (obj !== null) {
+      position = obj.offsetTop;
+      if (options.hasInnerContainers) {
+        position += getHeadingTopPos(obj.offsetParent);
+      }
+    }
+    return position;
+  }
+  __name(getHeadingTopPos, "getHeadingTopPos");
+  function updateClassname(obj, className) {
+    if (obj && obj.className !== className) {
+      obj.className = className;
+    }
+    return obj;
+  }
+  __name(updateClassname, "updateClassname");
+  function updateToc(headingsArray, event) {
+    if (options.positionFixedSelector) {
+      updateFixedSidebarClass();
+    }
+    const headings = headingsArray;
+    const clickedHref = event?.target?.getAttribute ? event?.target?.getAttribute("href") : null;
+    const isBottomMode = clickedHref && clickedHref.charAt(0) === "#" ? getIsHeaderBottomMode(clickedHref.replace("#", "")) : false;
+    const shouldUpdate = currentlyHighlighting || isBottomMode;
+    if (event && eventCount < 5) {
+      eventCount++;
+    }
+    if (shouldUpdate && !!tocElement && headings.length > 0) {
+      const topHeader = getTopHeader(headings);
+      const oldActiveTocLink = tocElement.querySelector(
+        `.${options.activeLinkClass}`
+      );
+      const topHeaderId = topHeader.id.replace(
+        /([ #;&,.+*~':"!^$[\]()=>|/\\@])/g,
+        "\\$1"
+      );
+      const hashId = window.location.hash.replace("#", "");
+      let activeId = topHeaderId;
+      const isPageBottomMode = getIsPageBottomMode();
+      if (clickedHref && isBottomMode) {
+        activeId = clickedHref.replace("#", "");
+      } else if (hashId && hashId !== topHeaderId && isPageBottomMode && (getIsHeaderBottomMode(topHeaderId) || eventCount <= 2)) {
+        activeId = hashId;
+      }
+      const activeTocLink = tocElement.querySelector(
+        `.${options.linkClass}[href="${options.basePath}#${activeId}"]`
+      );
+      if (oldActiveTocLink === activeTocLink) {
+        return;
+      }
+      const tocLinks = tocElement.querySelectorAll(`.${options.linkClass}`);
+      forEach.call(tocLinks, (tocLink) => {
+        updateClassname(
+          tocLink,
+          tocLink.className.replace(SPACE_CHAR + options.activeLinkClass, "")
+        );
+      });
+      const tocLis = tocElement.querySelectorAll(`.${options.listItemClass}`);
+      forEach.call(tocLis, (tocLi) => {
+        updateClassname(
+          tocLi,
+          tocLi.className.replace(SPACE_CHAR + options.activeListItemClass, "")
+        );
+      });
+      if (activeTocLink && activeTocLink.className.indexOf(options.activeLinkClass) === -1) {
+        activeTocLink.className += SPACE_CHAR + options.activeLinkClass;
+      }
+      const li = activeTocLink?.parentNode;
+      if (li && li.className.indexOf(options.activeListItemClass) === -1) {
+        li.className += SPACE_CHAR + options.activeListItemClass;
+      }
+      const tocLists = tocElement.querySelectorAll(
+        `.${options.listClass}.${options.collapsibleClass}`
+      );
+      forEach.call(tocLists, (list) => {
+        if (list.className.indexOf(options.isCollapsedClass) === -1) {
+          list.className += SPACE_CHAR + options.isCollapsedClass;
+        }
+      });
+      if (activeTocLink?.nextSibling && activeTocLink.nextSibling.className.indexOf(
+        options.isCollapsedClass
+      ) !== -1) {
+        updateClassname(
+          activeTocLink.nextSibling,
+          activeTocLink.nextSibling.className.replace(
+            SPACE_CHAR + options.isCollapsedClass,
+            ""
+          )
+        );
+      }
+      removeCollapsedFromParents(activeTocLink?.parentNode.parentNode);
+    }
+  }
+  __name(updateToc, "updateToc");
+  function removeCollapsedFromParents(element) {
+    if (element && element.className.indexOf(options.collapsibleClass) !== -1 && element.className.indexOf(options.isCollapsedClass) !== -1) {
+      updateClassname(
+        element,
+        element.className.replace(SPACE_CHAR + options.isCollapsedClass, "")
+      );
+      return removeCollapsedFromParents(element.parentNode.parentNode);
+    }
+    return element;
+  }
+  __name(removeCollapsedFromParents, "removeCollapsedFromParents");
+  function disableTocAnimation(event) {
+    const target = event.target || event.srcElement;
+    if (typeof target.className !== "string" || target.className.indexOf(options.linkClass) === -1) {
+      return;
+    }
+    currentlyHighlighting = false;
+  }
+  __name(disableTocAnimation, "disableTocAnimation");
+  function enableTocAnimation() {
+    currentlyHighlighting = true;
+  }
+  __name(enableTocAnimation, "enableTocAnimation");
+  function getCurrentlyHighlighting() {
+    return currentlyHighlighting;
+  }
+  __name(getCurrentlyHighlighting, "getCurrentlyHighlighting");
+  function getIsHeaderBottomMode(headerId) {
+    const scrollEl = getScrollEl();
+    const activeHeading = document?.getElementById(headerId);
+    const isBottomMode = activeHeading.offsetTop > scrollEl.offsetHeight - scrollEl.clientHeight * 1.4 - options.bottomModeThreshold;
+    return isBottomMode;
+  }
+  __name(getIsHeaderBottomMode, "getIsHeaderBottomMode");
+  function getIsPageBottomMode() {
+    const scrollEl = getScrollEl();
+    const isScrollable = scrollEl.scrollHeight > scrollEl.clientHeight;
+    const isBottomMode = getScrollTop() + scrollEl.clientHeight > scrollEl.offsetHeight - options.bottomModeThreshold;
+    return isScrollable && isBottomMode;
+  }
+  __name(getIsPageBottomMode, "getIsPageBottomMode");
+  function getScrollEl() {
+    let el;
+    if (options.scrollContainer && document.querySelector(options.scrollContainer)) {
+      el = document.querySelector(options.scrollContainer);
+    } else {
+      el = document.documentElement || body;
+    }
+    return el;
+  }
+  __name(getScrollEl, "getScrollEl");
+  function getScrollTop() {
+    const el = getScrollEl();
+    return el?.scrollTop || 0;
+  }
+  __name(getScrollTop, "getScrollTop");
+  function getTopHeader(headings, scrollTop = getScrollTop()) {
+    let topHeader;
+    some.call(headings, (heading, i) => {
+      if (getHeadingTopPos(heading) > scrollTop + options.headingsOffset + 10) {
+        const index = i === 0 ? i : i - 1;
+        topHeader = headings[index];
+        return true;
+      }
+      if (i === headings.length - 1) {
+        topHeader = headings[headings.length - 1];
+        return true;
+      }
+    });
+    return topHeader;
+  }
+  __name(getTopHeader, "getTopHeader");
+  function updateUrlHashForHeader(headingsArray) {
+    const scrollTop = getScrollTop();
+    const topHeader = getTopHeader(headingsArray, scrollTop);
+    const isPageBottomMode = getIsPageBottomMode();
+    if ((!topHeader || scrollTop < 5) && !isPageBottomMode) {
+      if (!(window.location.hash === "#" || window.location.hash === "")) {
+        window.history.pushState(null, null, "#");
+      }
+    } else if (topHeader && !isPageBottomMode) {
+      const newHash = `#${topHeader.id}`;
+      if (window.location.hash !== newHash) {
+        window.history.pushState(null, null, newHash);
+      }
+    }
+  }
+  __name(updateUrlHashForHeader, "updateUrlHashForHeader");
+  return {
+    enableTocAnimation,
+    disableTocAnimation,
+    render,
+    updateToc,
+    getCurrentlyHighlighting,
+    getTopHeader,
+    getScrollTop,
+    updateUrlHashForHeader
+  };
+}
+__name(build_html_default, "default");
+
+// ../../node_modules/tocbot/src/js/default-options.js
+var default_options_default = {
+  // Where to render the table of contents.
+  tocSelector: ".js-toc",
+  // Or, you can pass in a DOM node instead
+  tocElement: null,
+  // Where to grab the headings to build the table of contents.
+  contentSelector: ".js-toc-content",
+  // Or, you can pass in a DOM node instead
+  contentElement: null,
+  // Which headings to grab inside of the contentSelector element.
+  headingSelector: "h1, h2, h3",
+  // Headings that match the ignoreSelector will be skipped.
+  ignoreSelector: ".js-toc-ignore",
+  // For headings inside relative or absolute positioned
+  // containers within content.
+  hasInnerContainers: false,
+  // Main class to add to links.
+  linkClass: "toc-link",
+  // Extra classes to add to links.
+  extraLinkClasses: "",
+  // Class to add to active links,
+  // the link corresponding to the top most heading on the page.
+  activeLinkClass: "is-active-link",
+  // Main class to add to lists.
+  listClass: "toc-list",
+  // Extra classes to add to lists.
+  extraListClasses: "",
+  // Class that gets added when a list should be collapsed.
+  isCollapsedClass: "is-collapsed",
+  // Class that gets added when a list should be able
+  // to be collapsed but isn't necessarily collapsed.
+  collapsibleClass: "is-collapsible",
+  // Class to add to list items.
+  listItemClass: "toc-list-item",
+  // Class to add to active list items.
+  activeListItemClass: "is-active-li",
+  // How many heading levels should not be collapsed.
+  // For example, number 6 will show everything since
+  // there are only 6 heading levels and number 0 will collapse them all.
+  // The sections that are hidden will open
+  // and close as you scroll to headings within them.
+  collapseDepth: 0,
+  // Smooth scrolling enabled.
+  scrollSmooth: true,
+  // Smooth scroll duration.
+  scrollSmoothDuration: 420,
+  // Smooth scroll offset.
+  scrollSmoothOffset: 0,
+  // Callback for scroll end.
+  scrollEndCallback: /* @__PURE__ */ __name(function(e) {
+  }, "scrollEndCallback"),
+  // Headings offset between the headings and the top of
+  // the document (this is meant for minor adjustments).
+  headingsOffset: 1,
+  // Enable the URL hash to update with the proper heading ID as
+  // a user scrolls the page.
+  enableUrlHashUpdateOnScroll: false,
+  // type of scroll handler to use. to make scroll event not too rapid.
+  // Options are: "debounce" or "throttle"
+  // when set auto , use debounce less than 333ms , other use throttle.
+  // for ios browser can't use history.pushState() more than 100 times per 30 seconds reason
+  scrollHandlerType: "auto",
+  //  scrollHandler delay in ms.
+  scrollHandlerTimeout: 50,
+  // Timeout between events firing to make sure it's
+  // not too rapid (for performance reasons).
+  throttleTimeout: 50,
+  // Element to add the positionFixedClass to.
+  positionFixedSelector: null,
+  // Fixed position class to add to make sidebar fixed after scrolling
+  // down past the fixedSidebarOffset.
+  positionFixedClass: "is-position-fixed",
+  // fixedSidebarOffset can be any number but by default is set
+  // to auto which sets the fixedSidebarOffset to the sidebar
+  // element's offsetTop from the top of the document on init.
+  fixedSidebarOffset: "auto",
+  // includeHtml can be set to true to include the HTML markup from the
+  // heading node instead of just including the innerText.
+  includeHtml: false,
+  // includeTitleTags automatically sets the html title tag of the link
+  // to match the title. This can be useful for SEO purposes or
+  // when truncating titles.
+  includeTitleTags: false,
+  // onclick function to apply to all links in toc. will be called with
+  // the event as the first parameter, and this can be used to stop,
+  // propagation, prevent default or perform action
+  onClick: /* @__PURE__ */ __name(function(e) {
+  }, "onClick"),
+  // orderedList can be set to false to generate unordered lists (ul)
+  // instead of ordered lists (ol)
+  orderedList: true,
+  // If there is a fixed article scroll container, set to calculate offset.
+  scrollContainer: null,
+  // prevent ToC DOM rendering if it's already rendered by an external system.
+  skipRendering: false,
+  // Optional callback to change heading labels.
+  // For example it can be used to cut down and put ellipses on multiline headings you deem too long.
+  // Called each time a heading is parsed. Expects a string and returns the modified label to display.
+  // Additionally, the attribute `data-heading-label` may be used on a heading to specify
+  // a shorter string to be used in the TOC.
+  // function (string) => string
+  headingLabelCallback: false,
+  // ignore headings that are hidden in DOM
+  ignoreHiddenElements: false,
+  // Optional callback to modify properties of parsed headings.
+  // The heading element is passed in node parameter and information
+  // parsed by default parser is provided in obj parameter.
+  // Function has to return the same or modified obj.
+  // The heading will be excluded from TOC if nothing is returned.
+  // function (object, HTMLElement) => object | void
+  headingObjectCallback: null,
+  // Set the base path, useful if you use a `base` tag in `head`.
+  basePath: "",
+  // Only takes affect when `tocSelector` is scrolling,
+  // keep the toc scroll position in sync with the content.
+  disableTocScrollSync: false,
+  // If this is null then just use `tocElement` or `tocSelector` instead
+  // assuming `disableTocScrollSync` is set to false. This allows for
+  // scrolling an outer element (like a nav panel w/ search) containing the toc.
+  // Please pass an element, not a selector here.
+  tocScrollingWrapper: null,
+  // Offset for the toc scroll (top) position when scrolling the page.
+  // Only effective if `disableTocScrollSync` is false.
+  tocScrollOffset: 30,
+  // Threshold for when bottom mode should be enabled to handle
+  // highlighting links that cannot be scrolled to.
+  bottomModeThreshold: 30
+};
+
+// ../../node_modules/tocbot/src/js/parse-content.js
+function parseContent(options) {
+  const reduce = [].reduce;
+  function getLastItem(array) {
+    return array[array.length - 1];
+  }
+  __name(getLastItem, "getLastItem");
+  function getHeadingLevel(heading) {
+    return +heading.nodeName.toUpperCase().replace("H", "");
+  }
+  __name(getHeadingLevel, "getHeadingLevel");
+  function isHTMLElement(maybeElement) {
+    try {
+      return maybeElement instanceof window.HTMLElement || maybeElement instanceof window.parent.HTMLElement;
+    } catch (e) {
+      return maybeElement instanceof window.HTMLElement;
+    }
+  }
+  __name(isHTMLElement, "isHTMLElement");
+  function getHeadingObject(heading) {
+    if (!isHTMLElement(heading)) return heading;
+    if (options.ignoreHiddenElements && (!heading.offsetHeight || !heading.offsetParent)) {
+      return null;
+    }
+    const headingLabel = heading.getAttribute("data-heading-label") || (options.headingLabelCallback ? String(options.headingLabelCallback(heading.innerText)) : (heading.innerText || heading.textContent).trim());
+    const obj = {
+      id: heading.id,
+      children: [],
+      nodeName: heading.nodeName,
+      headingLevel: getHeadingLevel(heading),
+      textContent: headingLabel
+    };
+    if (options.includeHtml) {
+      obj.childNodes = heading.childNodes;
+    }
+    if (options.headingObjectCallback) {
+      return options.headingObjectCallback(obj, heading);
+    }
+    return obj;
+  }
+  __name(getHeadingObject, "getHeadingObject");
+  function addNode(node, nest) {
+    const obj = getHeadingObject(node);
+    const level = obj.headingLevel;
+    let array = nest;
+    let lastItem = getLastItem(array);
+    const lastItemLevel = lastItem ? lastItem.headingLevel : 0;
+    let counter = level - lastItemLevel;
+    while (counter > 0) {
+      lastItem = getLastItem(array);
+      if (lastItem && level === lastItem.headingLevel) {
+        break;
+      } else if (lastItem && lastItem.children !== void 0) {
+        array = lastItem.children;
+      }
+      counter--;
+    }
+    if (level >= options.collapseDepth) {
+      obj.isCollapsed = true;
+    }
+    array.push(obj);
+    return array;
+  }
+  __name(addNode, "addNode");
+  function selectHeadings(contentElement, headingSelector) {
+    let selectors = headingSelector;
+    if (options.ignoreSelector) {
+      selectors = headingSelector.split(",").map(/* @__PURE__ */ __name(function mapSelectors(selector) {
+        return `${selector.trim()}:not(${options.ignoreSelector})`;
+      }, "mapSelectors"));
+    }
+    try {
+      return contentElement.querySelectorAll(selectors);
+    } catch (e) {
+      console.warn(`Headers not found with selector: ${selectors}`);
+      return null;
+    }
+  }
+  __name(selectHeadings, "selectHeadings");
+  function nestHeadingsArray(headingsArray) {
+    return reduce.call(
+      headingsArray,
+      /* @__PURE__ */ __name(function reducer(prev, curr) {
+        const currentHeading = getHeadingObject(curr);
+        if (currentHeading) {
+          addNode(currentHeading, prev.nest);
+        }
+        return prev;
+      }, "reducer"),
+      {
+        nest: []
+      }
+    );
+  }
+  __name(nestHeadingsArray, "nestHeadingsArray");
+  return {
+    nestHeadingsArray,
+    selectHeadings
+  };
+}
+__name(parseContent, "parseContent");
+
+// ../../node_modules/tocbot/src/js/scroll-smooth/index.js
+function initSmoothScrolling(options) {
+  var duration = options.duration;
+  var offset = options.offset;
+  if (typeof window === "undefined" || typeof location === "undefined") return;
+  var pageUrl = location.hash ? stripHash(location.href) : location.href;
+  delegatedLinkHijacking();
+  function delegatedLinkHijacking() {
+    document.body.addEventListener("click", onClick, false);
+    function onClick(e) {
+      if (!isInPageLink(e.target) || e.target.className.indexOf("no-smooth-scroll") > -1 || e.target.href.charAt(e.target.href.length - 2) === "#" && e.target.href.charAt(e.target.href.length - 1) === "!" || e.target.className.indexOf(options.linkClass) === -1) {
+        return;
+      }
+      jump(e.target.hash, {
+        duration,
+        offset,
+        callback: /* @__PURE__ */ __name(function() {
+          setFocus(e.target.hash);
+        }, "callback")
+      });
+    }
+    __name(onClick, "onClick");
+  }
+  __name(delegatedLinkHijacking, "delegatedLinkHijacking");
+  function isInPageLink(n) {
+    return n.tagName.toLowerCase() === "a" && (n.hash.length > 0 || n.href.charAt(n.href.length - 1) === "#") && (stripHash(n.href) === pageUrl || stripHash(n.href) + "#" === pageUrl);
+  }
+  __name(isInPageLink, "isInPageLink");
+  function stripHash(url) {
+    return url.slice(0, url.lastIndexOf("#"));
+  }
+  __name(stripHash, "stripHash");
+  function setFocus(hash) {
+    var element = document.getElementById(hash.substring(1));
+    if (element) {
+      if (!/^(?:a|select|input|button|textarea)$/i.test(element.tagName)) {
+        element.tabIndex = -1;
+      }
+      element.focus();
+    }
+  }
+  __name(setFocus, "setFocus");
+}
+__name(initSmoothScrolling, "initSmoothScrolling");
+function jump(target, options) {
+  var start = window.pageYOffset;
+  var opt = {
+    duration: options.duration,
+    offset: options.offset || 0,
+    callback: options.callback,
+    easing: options.easing || easeInOutQuad
+  };
+  var tgt = document.querySelector(
+    '[id="' + decodeURI(target).split("#").join("") + '"]'
+  ) || document.querySelector('[id="' + target.split("#").join("") + '"]');
+  var distance = typeof target === "string" ? opt.offset + (target ? tgt && tgt.getBoundingClientRect().top || 0 : -(document.documentElement.scrollTop || document.body.scrollTop)) : target;
+  var duration = typeof opt.duration === "function" ? opt.duration(distance) : opt.duration;
+  var timeStart;
+  var timeElapsed;
+  requestAnimationFrame(function(time) {
+    timeStart = time;
+    loop(time);
+  });
+  function loop(time) {
+    timeElapsed = time - timeStart;
+    window.scrollTo(0, opt.easing(timeElapsed, start, distance, duration));
+    if (timeElapsed < duration) {
+      requestAnimationFrame(loop);
+    } else {
+      end();
+    }
+  }
+  __name(loop, "loop");
+  function end() {
+    window.scrollTo(0, start + distance);
+    if (typeof opt.callback === "function") {
+      opt.callback();
+    }
+  }
+  __name(end, "end");
+  function easeInOutQuad(t, b, c, d) {
+    t /= d / 2;
+    if (t < 1) return c / 2 * t * t + b;
+    t--;
+    return -c / 2 * (t * (t - 2) - 1) + b;
+  }
+  __name(easeInOutQuad, "easeInOutQuad");
+}
+__name(jump, "jump");
+
+// ../../node_modules/tocbot/src/js/update-toc-scroll.js
+function updateTocScroll(options) {
+  const toc = options.tocScrollingWrapper || options.tocElement || document.querySelector(options.tocSelector);
+  if (toc && toc.scrollHeight > toc.clientHeight) {
+    const activeItem = toc.querySelector(`.${options.activeListItemClass}`);
+    if (activeItem) {
+      const eTop = activeItem.offsetTop;
+      const scrollAmount = eTop - options.tocScrollOffset;
+      toc.scrollTop = scrollAmount > 0 ? scrollAmount : 0;
+    }
+  }
+}
+__name(updateTocScroll, "updateTocScroll");
+
+// ../../node_modules/tocbot/src/js/index-esm.js
+var _options = {};
+var _buildHtml;
+var _parseContent;
+var _headingsArray;
+var _scrollListener;
+var clickListener;
+function init(customOptions) {
+  let hasInitialized = false;
+  _options = extend(default_options_default, customOptions || {});
+  if (_options.scrollSmooth) {
+    _options.duration = _options.scrollSmoothDuration;
+    _options.offset = _options.scrollSmoothOffset;
+    initSmoothScrolling(_options);
+  }
+  _buildHtml = build_html_default(_options);
+  _parseContent = parseContent(_options);
+  destroy();
+  const contentElement = getContentElement(_options);
+  if (contentElement === null) {
+    return;
+  }
+  const tocElement = getTocElement(_options);
+  if (tocElement === null) {
+    return;
+  }
+  _headingsArray = _parseContent.selectHeadings(
+    contentElement,
+    _options.headingSelector
+  );
+  if (_headingsArray === null) {
+    return;
+  }
+  const nestedHeadingsObj = _parseContent.nestHeadingsArray(_headingsArray);
+  const nestedHeadings = nestedHeadingsObj.nest;
+  if (!_options.skipRendering) {
+    _buildHtml.render(tocElement, nestedHeadings);
+  } else {
+    return this;
+  }
+  let isClick = false;
+  const scrollHandlerTimeout = _options.scrollHandlerTimeout || _options.throttleTimeout;
+  const scrollHandler = /* @__PURE__ */ __name((fn, delay) => getScrollHandler(fn, delay, _options.scrollHandlerType), "scrollHandler");
+  _scrollListener = scrollHandler((e) => {
+    _buildHtml.updateToc(_headingsArray, e);
+    !_options.disableTocScrollSync && !isClick && updateTocScroll(_options);
+    if (_options.enableUrlHashUpdateOnScroll && hasInitialized) {
+      const enableUpdatingHash = _buildHtml.getCurrentlyHighlighting();
+      enableUpdatingHash && _buildHtml.updateUrlHashForHeader(_headingsArray);
+    }
+    const isTop = e?.target?.scrollingElement?.scrollTop === 0;
+    if (e && (e.eventPhase === 0 || e.currentTarget === null) || isTop) {
+      _buildHtml.updateToc(_headingsArray);
+      _options.scrollEndCallback?.(e);
+    }
+  }, scrollHandlerTimeout);
+  if (!hasInitialized) {
+    _scrollListener();
+    hasInitialized = true;
+  }
+  window.onhashchange = window.onscrollend = (e) => {
+    _scrollListener(e);
+  };
+  if (_options.scrollContainer && document.querySelector(_options.scrollContainer)) {
+    document.querySelector(_options.scrollContainer).addEventListener("scroll", _scrollListener, false);
+    document.querySelector(_options.scrollContainer).addEventListener("resize", _scrollListener, false);
+  } else {
+    document.addEventListener("scroll", _scrollListener, false);
+    document.addEventListener("resize", _scrollListener, false);
+  }
+  let timeout = null;
+  clickListener = throttle((event) => {
+    isClick = true;
+    if (_options.scrollSmooth) {
+      _buildHtml.disableTocAnimation(event);
+    }
+    _buildHtml.updateToc(_headingsArray, event);
+    timeout && clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      _buildHtml.enableTocAnimation();
+    }, _options.scrollSmoothDuration);
+    setTimeout(() => {
+      isClick = false;
+    }, _options.scrollSmoothDuration + 100);
+  }, _options.throttleTimeout);
+  if (_options.scrollContainer && document.querySelector(_options.scrollContainer)) {
+    document.querySelector(_options.scrollContainer).addEventListener("click", clickListener, false);
+  } else {
+    document.addEventListener("click", clickListener, false);
+  }
+}
+__name(init, "init");
+function destroy() {
+  const tocElement = getTocElement(_options);
+  if (tocElement === null) {
+    return;
+  }
+  if (!_options.skipRendering) {
+    if (tocElement) {
+      tocElement.innerHTML = "";
+    }
+  }
+  if (_options.scrollContainer && document.querySelector(_options.scrollContainer)) {
+    document.querySelector(_options.scrollContainer).removeEventListener("scroll", _scrollListener, false);
+    document.querySelector(_options.scrollContainer).removeEventListener("resize", _scrollListener, false);
+    if (_buildHtml) {
+      document.querySelector(_options.scrollContainer).removeEventListener("click", clickListener, false);
+    }
+  } else {
+    document.removeEventListener("scroll", _scrollListener, false);
+    document.removeEventListener("resize", _scrollListener, false);
+    if (_buildHtml) {
+      document.removeEventListener("click", clickListener, false);
+    }
+  }
+}
+__name(destroy, "destroy");
+function refresh(customOptions) {
+  destroy();
+  init(customOptions || _options);
+}
+__name(refresh, "refresh");
+var hasOwnProp = Object.prototype.hasOwnProperty;
+function extend(...args) {
+  const target = {};
+  for (let i = 0; i < args.length; i++) {
+    const source = args[i];
+    for (const key in source) {
+      if (hasOwnProp.call(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+}
+__name(extend, "extend");
+function throttle(fn, threshold, scope) {
+  threshold || (threshold = 250);
+  let last;
+  let deferTimer;
+  return function(...args) {
+    const context = scope || this;
+    const now = +/* @__PURE__ */ new Date();
+    if (last && now < last + threshold) {
+      clearTimeout(deferTimer);
+      deferTimer = setTimeout(() => {
+        last = now;
+        fn.apply(context, args);
+      }, threshold);
+    } else {
+      last = now;
+      fn.apply(context, args);
+    }
+  };
+}
+__name(throttle, "throttle");
+function debounce(func, wait) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func.apply(this, args), wait);
+  };
+}
+__name(debounce, "debounce");
+function getScrollHandler(func, timeout, type = "auto") {
+  switch (type) {
+    case "debounce":
+      return debounce(func, timeout);
+    case "throttle":
+      return throttle(func, timeout);
+    default:
+      return timeout < 334 ? debounce(func, timeout) : throttle(func, timeout);
+  }
+}
+__name(getScrollHandler, "getScrollHandler");
+function getContentElement(options) {
+  try {
+    return options.contentElement || document.querySelector(options.contentSelector);
+  } catch (e) {
+    console.warn(`Contents element not found: ${options.contentSelector}`);
+    return null;
+  }
+}
+__name(getContentElement, "getContentElement");
+function getTocElement(options) {
+  try {
+    return options.tocElement || document.querySelector(options.tocSelector);
+  } catch (e) {
+    console.warn(`TOC element not found: ${options.tocSelector}`);
+    return null;
+  }
+}
+__name(getTocElement, "getTocElement");
+
+// ../../node_modules/tocbot/index.js
+var tocbot = { destroy, init, refresh };
+var tocbot_default = tocbot;
+
+export {
+  tocbot_default,
+  tocbot_exports
+};