@hyperbook/markdown 0.7.0 → 0.8.1

package/dist/index.esm.mjs

@@ -1,7 +1,11 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -17,6 +21,125 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/is-buffer@2.0.5/node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS({
+  "../../node_modules/.pnpm/is-buffer@2.0.5/node_modules/is-buffer/index.js"(exports, module) {
+    module.exports = function isBuffer2(obj) {
+      return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/extend@3.0.2/node_modules/extend/index.js
+var require_extend = __commonJS({
+  "../../node_modules/.pnpm/extend@3.0.2/node_modules/extend/index.js"(exports, module) {
+    "use strict";
+    var hasOwn = Object.prototype.hasOwnProperty;
+    var toStr = Object.prototype.toString;
+    var defineProperty = Object.defineProperty;
+    var gOPD = Object.getOwnPropertyDescriptor;
+    var isArray = function isArray2(arr) {
+      if (typeof Array.isArray === "function") {
+        return Array.isArray(arr);
+      }
+      return toStr.call(arr) === "[object Array]";
+    };
+    var isPlainObject2 = function isPlainObject3(obj) {
+      if (!obj || toStr.call(obj) !== "[object Object]") {
+        return false;
+      }
+      var hasOwnConstructor = hasOwn.call(obj, "constructor");
+      var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
+      if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+        return false;
+      }
+      var key;
+      for (key in obj) {
+      }
+      return typeof key === "undefined" || hasOwn.call(obj, key);
+    };
+    var setProperty = function setProperty2(target, options) {
+      if (defineProperty && options.name === "__proto__") {
+        defineProperty(target, options.name, {
+          enumerable: true,
+          configurable: true,
+          value: options.newValue,
+          writable: true
+        });
+      } else {
+        target[options.name] = options.newValue;
+      }
+    };
+    var getProperty = function getProperty2(obj, name) {
+      if (name === "__proto__") {
+        if (!hasOwn.call(obj, name)) {
+          return void 0;
+        } else if (gOPD) {
+          return gOPD(obj, name).value;
+        }
+      }
+      return obj[name];
+    };
+    module.exports = function extend2() {
+      var options, name, src, copy, copyIsArray, clone;
+      var target = arguments[0];
+      var i = 1;
+      var length = arguments.length;
+      var deep = false;
+      if (typeof target === "boolean") {
+        deep = target;
+        target = arguments[1] || {};
+        i = 2;
+      }
+      if (target == null || typeof target !== "object" && typeof target !== "function") {
+        target = {};
+      }
+      for (; i < length; ++i) {
+        options = arguments[i];
+        if (options != null) {
+          for (name in options) {
+            src = getProperty(target, name);
+            copy = getProperty(options, name);
+            if (target !== copy) {
+              if (deep && copy && (isPlainObject2(copy) || (copyIsArray = isArray(copy)))) {
+                if (copyIsArray) {
+                  copyIsArray = false;
+                  clone = src && isArray(src) ? src : [];
+                } else {
+                  clone = src && isPlainObject2(src) ? src : {};
+                }
+                setProperty(target, { name, newValue: extend2(deep, clone, copy) });
+              } else if (typeof copy !== "undefined") {
+                setProperty(target, { name, newValue: copy });
+              }
+            }
+          }
+        }
+      }
+      return target;
+    };
+  }
+});
 
 // src/Markdown.tsx
 import remarkDirective from "remark-directive";
@@ -28,6 +151,7 @@ import remarkUnwrapImages from "remark-unwrap-images";
 import rehypeKatex from "rehype-katex";
 import rehypeHighlight from "rehype-highlight";
 import { useDirectives as useDirectives2 } from "@hyperbook/provider";
+import { Drawer } from "@hyperbook/drawer";
 
 // src/Code.tsx
 import { useDirectives } from "@hyperbook/provider";
@@ -274,11 +398,11 @@ var Image = ({
 import { visit, SKIP } from "unist-util-visit";
 var remarkRemoveComments = () => (tree) => {
   const htmlCommentRegex = /<!--([\s\S]*?)-->/g;
-  const handler = (node, index, parent) => {
+  const handler = (node, index2, parent) => {
     const isComment = node.value.match(htmlCommentRegex);
     if (isComment) {
-      parent.children.splice(index, 1);
-      return [SKIP, index];
+      parent.children.splice(index2, 1);
+      return [SKIP, index2];
     }
   };
   visit(tree, "html", handler);
@@ -315,7 +439,1067 @@ var remarkCustomHeadingIds = () => {
 
 // src/useRemarkSync.ts
 import { Fragment as Fragment3, createElement } from "react";
-import { unified } from "unified";
+
+// ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
+function bail(error) {
+  if (error) {
+    throw error;
+  }
+}
+
+// ../../node_modules/.pnpm/unified@10.1.2/node_modules/unified/lib/index.js
+var import_is_buffer2 = __toESM(require_is_buffer(), 1);
+var import_extend = __toESM(require_extend(), 1);
+
+// ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+// ../../node_modules/.pnpm/trough@2.1.0/node_modules/trough/index.js
+function trough() {
+  const fns = [];
+  const pipeline = { run, use };
+  return pipeline;
+  function run(...values) {
+    let middlewareIndex = -1;
+    const callback = values.pop();
+    if (typeof callback !== "function") {
+      throw new TypeError("Expected function as last argument, not " + callback);
+    }
+    next(null, ...values);
+    function next(error, ...output) {
+      const fn = fns[++middlewareIndex];
+      let index2 = -1;
+      if (error) {
+        callback(error);
+        return;
+      }
+      while (++index2 < values.length) {
+        if (output[index2] === null || output[index2] === void 0) {
+          output[index2] = values[index2];
+        }
+      }
+      values = output;
+      if (fn) {
+        wrap(fn, next)(...output);
+      } else {
+        callback(null, ...output);
+      }
+    }
+  }
+  function use(middelware) {
+    if (typeof middelware !== "function") {
+      throw new TypeError(
+        "Expected `middelware` to be a function, not " + middelware
+      );
+    }
+    fns.push(middelware);
+    return pipeline;
+  }
+}
+function wrap(middleware, callback) {
+  let called;
+  return wrapped;
+  function wrapped(...parameters) {
+    const fnExpectsCallback = middleware.length > parameters.length;
+    let result;
+    if (fnExpectsCallback) {
+      parameters.push(done);
+    }
+    try {
+      result = middleware.apply(this, parameters);
+    } catch (error) {
+      const exception = (
+        /** @type {Error} */
+        error
+      );
+      if (fnExpectsCallback && called) {
+        throw exception;
+      }
+      return done(exception);
+    }
+    if (!fnExpectsCallback) {
+      if (result instanceof Promise) {
+        result.then(then, done);
+      } else if (result instanceof Error) {
+        done(result);
+      } else {
+        then(result);
+      }
+    }
+  }
+  function done(error, ...output) {
+    if (!called) {
+      called = true;
+      callback(error, ...output);
+    }
+  }
+  function then(value) {
+    done(null, value);
+  }
+}
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/index.js
+var import_is_buffer = __toESM(require_is_buffer(), 1);
+
+// ../../node_modules/.pnpm/unist-util-stringify-position@3.0.3/node_modules/unist-util-stringify-position/lib/index.js
+function stringifyPosition(value) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  if ("position" in value || "type" in value) {
+    return position(value.position);
+  }
+  if ("start" in value || "end" in value) {
+    return position(value);
+  }
+  if ("line" in value || "column" in value) {
+    return point(value);
+  }
+  return "";
+}
+function point(point2) {
+  return index(point2 && point2.line) + ":" + index(point2 && point2.column);
+}
+function position(pos) {
+  return point(pos && pos.start) + "-" + point(pos && pos.end);
+}
+function index(value) {
+  return value && typeof value === "number" ? value : 1;
+}
+
+// ../../node_modules/.pnpm/vfile-message@3.1.4/node_modules/vfile-message/lib/index.js
+var VFileMessage = class extends Error {
+  /**
+   * Create a message for `reason` at `place` from `origin`.
+   *
+   * When an error is passed in as `reason`, the `stack` is copied.
+   *
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   *
+   *   > 👉 **Note**: you should use markdown.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns
+   *   Instance of `VFileMessage`.
+   */
+  // To do: next major: expose `undefined` everywhere instead of `null`.
+  constructor(reason, place, origin) {
+    const parts = [null, null];
+    let position2 = {
+      // @ts-expect-error: we always follows the structure of `position`.
+      start: { line: null, column: null },
+      // @ts-expect-error: "
+      end: { line: null, column: null }
+    };
+    super();
+    if (typeof place === "string") {
+      origin = place;
+      place = void 0;
+    }
+    if (typeof origin === "string") {
+      const index2 = origin.indexOf(":");
+      if (index2 === -1) {
+        parts[1] = origin;
+      } else {
+        parts[0] = origin.slice(0, index2);
+        parts[1] = origin.slice(index2 + 1);
+      }
+    }
+    if (place) {
+      if ("type" in place || "position" in place) {
+        if (place.position) {
+          position2 = place.position;
+        }
+      } else if ("start" in place || "end" in place) {
+        position2 = place;
+      } else if ("line" in place || "column" in place) {
+        position2.start = place;
+      }
+    }
+    this.name = stringifyPosition(place) || "1:1";
+    this.message = typeof reason === "object" ? reason.message : reason;
+    this.stack = "";
+    if (typeof reason === "object" && reason.stack) {
+      this.stack = reason.stack;
+    }
+    this.reason = this.message;
+    this.fatal;
+    this.line = position2.start.line;
+    this.column = position2.start.column;
+    this.position = position2;
+    this.source = parts[0];
+    this.ruleId = parts[1];
+    this.file;
+    this.actual;
+    this.expected;
+    this.url;
+    this.note;
+  }
+};
+VFileMessage.prototype.file = "";
+VFileMessage.prototype.name = "";
+VFileMessage.prototype.reason = "";
+VFileMessage.prototype.message = "";
+VFileMessage.prototype.stack = "";
+VFileMessage.prototype.fatal = null;
+VFileMessage.prototype.column = null;
+VFileMessage.prototype.line = null;
+VFileMessage.prototype.source = null;
+VFileMessage.prototype.ruleId = null;
+VFileMessage.prototype.position = null;
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/minpath.browser.js
+var path = { basename, dirname, extname, join, sep: "/" };
+function basename(path2, ext) {
+  if (ext !== void 0 && typeof ext !== "string") {
+    throw new TypeError('"ext" argument must be a string');
+  }
+  assertPath(path2);
+  let start = 0;
+  let end = -1;
+  let index2 = path2.length;
+  let seenNonSlash;
+  if (ext === void 0 || ext.length === 0 || ext.length > path2.length) {
+    while (index2--) {
+      if (path2.charCodeAt(index2) === 47) {
+        if (seenNonSlash) {
+          start = index2 + 1;
+          break;
+        }
+      } else if (end < 0) {
+        seenNonSlash = true;
+        end = index2 + 1;
+      }
+    }
+    return end < 0 ? "" : path2.slice(start, end);
+  }
+  if (ext === path2) {
+    return "";
+  }
+  let firstNonSlashEnd = -1;
+  let extIndex = ext.length - 1;
+  while (index2--) {
+    if (path2.charCodeAt(index2) === 47) {
+      if (seenNonSlash) {
+        start = index2 + 1;
+        break;
+      }
+    } else {
+      if (firstNonSlashEnd < 0) {
+        seenNonSlash = true;
+        firstNonSlashEnd = index2 + 1;
+      }
+      if (extIndex > -1) {
+        if (path2.charCodeAt(index2) === ext.charCodeAt(extIndex--)) {
+          if (extIndex < 0) {
+            end = index2;
+          }
+        } else {
+          extIndex = -1;
+          end = firstNonSlashEnd;
+        }
+      }
+    }
+  }
+  if (start === end) {
+    end = firstNonSlashEnd;
+  } else if (end < 0) {
+    end = path2.length;
+  }
+  return path2.slice(start, end);
+}
+function dirname(path2) {
+  assertPath(path2);
+  if (path2.length === 0) {
+    return ".";
+  }
+  let end = -1;
+  let index2 = path2.length;
+  let unmatchedSlash;
+  while (--index2) {
+    if (path2.charCodeAt(index2) === 47) {
+      if (unmatchedSlash) {
+        end = index2;
+        break;
+      }
+    } else if (!unmatchedSlash) {
+      unmatchedSlash = true;
+    }
+  }
+  return end < 0 ? path2.charCodeAt(0) === 47 ? "/" : "." : end === 1 && path2.charCodeAt(0) === 47 ? "//" : path2.slice(0, end);
+}
+function extname(path2) {
+  assertPath(path2);
+  let index2 = path2.length;
+  let end = -1;
+  let startPart = 0;
+  let startDot = -1;
+  let preDotState = 0;
+  let unmatchedSlash;
+  while (index2--) {
+    const code = path2.charCodeAt(index2);
+    if (code === 47) {
+      if (unmatchedSlash) {
+        startPart = index2 + 1;
+        break;
+      }
+      continue;
+    }
+    if (end < 0) {
+      unmatchedSlash = true;
+      end = index2 + 1;
+    }
+    if (code === 46) {
+      if (startDot < 0) {
+        startDot = index2;
+      } else if (preDotState !== 1) {
+        preDotState = 1;
+      }
+    } else if (startDot > -1) {
+      preDotState = -1;
+    }
+  }
+  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.
+  preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.
+  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    return "";
+  }
+  return path2.slice(startDot, end);
+}
+function join(...segments) {
+  let index2 = -1;
+  let joined;
+  while (++index2 < segments.length) {
+    assertPath(segments[index2]);
+    if (segments[index2]) {
+      joined = joined === void 0 ? segments[index2] : joined + "/" + segments[index2];
+    }
+  }
+  return joined === void 0 ? "." : normalize(joined);
+}
+function normalize(path2) {
+  assertPath(path2);
+  const absolute = path2.charCodeAt(0) === 47;
+  let value = normalizeString(path2, !absolute);
+  if (value.length === 0 && !absolute) {
+    value = ".";
+  }
+  if (value.length > 0 && path2.charCodeAt(path2.length - 1) === 47) {
+    value += "/";
+  }
+  return absolute ? "/" + value : value;
+}
+function normalizeString(path2, allowAboveRoot) {
+  let result = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let index2 = -1;
+  let code;
+  let lastSlashIndex;
+  while (++index2 <= path2.length) {
+    if (index2 < path2.length) {
+      code = path2.charCodeAt(index2);
+    } else if (code === 47) {
+      break;
+    } else {
+      code = 47;
+    }
+    if (code === 47) {
+      if (lastSlash === index2 - 1 || dots === 1) {
+      } else if (lastSlash !== index2 - 1 && dots === 2) {
+        if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46 || result.charCodeAt(result.length - 2) !== 46) {
+          if (result.length > 2) {
+            lastSlashIndex = result.lastIndexOf("/");
+            if (lastSlashIndex !== result.length - 1) {
+              if (lastSlashIndex < 0) {
+                result = "";
+                lastSegmentLength = 0;
+              } else {
+                result = result.slice(0, lastSlashIndex);
+                lastSegmentLength = result.length - 1 - result.lastIndexOf("/");
+              }
+              lastSlash = index2;
+              dots = 0;
+              continue;
+            }
+          } else if (result.length > 0) {
+            result = "";
+            lastSegmentLength = 0;
+            lastSlash = index2;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          result = result.length > 0 ? result + "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (result.length > 0) {
+          result += "/" + path2.slice(lastSlash + 1, index2);
+        } else {
+          result = path2.slice(lastSlash + 1, index2);
+        }
+        lastSegmentLength = index2 - lastSlash - 1;
+      }
+      lastSlash = index2;
+      dots = 0;
+    } else if (code === 46 && dots > -1) {
+      dots++;
+    } else {
+      dots = -1;
+    }
+  }
+  return result;
+}
+function assertPath(path2) {
+  if (typeof path2 !== "string") {
+    throw new TypeError(
+      "Path must be a string. Received " + JSON.stringify(path2)
+    );
+  }
+}
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/minproc.browser.js
+var proc = { cwd };
+function cwd() {
+  return "/";
+}
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/minurl.shared.js
+function isUrl(fileUrlOrPath) {
+  return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable.
+  fileUrlOrPath.href && // @ts-expect-error: indexable.
+  fileUrlOrPath.origin;
+}
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/minurl.browser.js
+function urlToPath(path2) {
+  if (typeof path2 === "string") {
+    path2 = new URL(path2);
+  } else if (!isUrl(path2)) {
+    const error = new TypeError(
+      'The "path" argument must be of type string or an instance of URL. Received `' + path2 + "`"
+    );
+    error.code = "ERR_INVALID_ARG_TYPE";
+    throw error;
+  }
+  if (path2.protocol !== "file:") {
+    const error = new TypeError("The URL must be of scheme file");
+    error.code = "ERR_INVALID_URL_SCHEME";
+    throw error;
+  }
+  return getPathFromURLPosix(path2);
+}
+function getPathFromURLPosix(url) {
+  if (url.hostname !== "") {
+    const error = new TypeError(
+      'File URL host must be "localhost" or empty on darwin'
+    );
+    error.code = "ERR_INVALID_FILE_URL_HOST";
+    throw error;
+  }
+  const pathname = url.pathname;
+  let index2 = -1;
+  while (++index2 < pathname.length) {
+    if (pathname.charCodeAt(index2) === 37 && pathname.charCodeAt(index2 + 1) === 50) {
+      const third = pathname.charCodeAt(index2 + 2);
+      if (third === 70 || third === 102) {
+        const error = new TypeError(
+          "File URL path must not include encoded / characters"
+        );
+        error.code = "ERR_INVALID_FILE_URL_PATH";
+        throw error;
+      }
+    }
+  }
+  return decodeURIComponent(pathname);
+}
+
+// ../../node_modules/.pnpm/vfile@5.3.7/node_modules/vfile/lib/index.js
+var order = ["history", "path", "basename", "stem", "extname", "dirname"];
+var VFile = class {
+  /**
+   * Create a new virtual file.
+   *
+   * `options` is treated as:
+   *
+   * *   `string` or `Buffer` — `{value: options}`
+   * *   `URL` — `{path: options}`
+   * *   `VFile` — shallow copies its data over to the new file
+   * *   `object` — all fields are shallow copied over to the new file
+   *
+   * Path related fields are set in the following order (least specific to
+   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
+   * `dirname`.
+   *
+   * You cannot set `dirname` or `extname` without setting either `history`,
+   * `path`, `basename`, or `stem` too.
+   *
+   * @param {Compatible | null | undefined} [value]
+   *   File value.
+   * @returns
+   *   New instance.
+   */
+  constructor(value) {
+    let options;
+    if (!value) {
+      options = {};
+    } else if (typeof value === "string" || buffer(value)) {
+      options = { value };
+    } else if (isUrl(value)) {
+      options = { path: value };
+    } else {
+      options = value;
+    }
+    this.data = {};
+    this.messages = [];
+    this.history = [];
+    this.cwd = proc.cwd();
+    this.value;
+    this.stored;
+    this.result;
+    this.map;
+    let index2 = -1;
+    while (++index2 < order.length) {
+      const prop2 = order[index2];
+      if (prop2 in options && options[prop2] !== void 0 && options[prop2] !== null) {
+        this[prop2] = prop2 === "history" ? [...options[prop2]] : options[prop2];
+      }
+    }
+    let prop;
+    for (prop in options) {
+      if (!order.includes(prop)) {
+        this[prop] = options[prop];
+      }
+    }
+  }
+  /**
+   * Get the full path (example: `'~/index.min.js'`).
+   *
+   * @returns {string}
+   */
+  get path() {
+    return this.history[this.history.length - 1];
+  }
+  /**
+   * Set the full path (example: `'~/index.min.js'`).
+   *
+   * Cannot be nullified.
+   * You can set a file URL (a `URL` object with a `file:` protocol) which will
+   * be turned into a path with `url.fileURLToPath`.
+   *
+   * @param {string | URL} path
+   */
+  set path(path2) {
+    if (isUrl(path2)) {
+      path2 = urlToPath(path2);
+    }
+    assertNonEmpty(path2, "path");
+    if (this.path !== path2) {
+      this.history.push(path2);
+    }
+  }
+  /**
+   * Get the parent path (example: `'~'`).
+   */
+  get dirname() {
+    return typeof this.path === "string" ? path.dirname(this.path) : void 0;
+  }
+  /**
+   * Set the parent path (example: `'~'`).
+   *
+   * Cannot be set if there’s no `path` yet.
+   */
+  set dirname(dirname2) {
+    assertPath2(this.basename, "dirname");
+    this.path = path.join(dirname2 || "", this.basename);
+  }
+  /**
+   * Get the basename (including extname) (example: `'index.min.js'`).
+   */
+  get basename() {
+    return typeof this.path === "string" ? path.basename(this.path) : void 0;
+  }
+  /**
+   * Set basename (including extname) (`'index.min.js'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   */
+  set basename(basename2) {
+    assertNonEmpty(basename2, "basename");
+    assertPart(basename2, "basename");
+    this.path = path.join(this.dirname || "", basename2);
+  }
+  /**
+   * Get the extname (including dot) (example: `'.js'`).
+   */
+  get extname() {
+    return typeof this.path === "string" ? path.extname(this.path) : void 0;
+  }
+  /**
+   * Set the extname (including dot) (example: `'.js'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be set if there’s no `path` yet.
+   */
+  set extname(extname2) {
+    assertPart(extname2, "extname");
+    assertPath2(this.dirname, "extname");
+    if (extname2) {
+      if (extname2.charCodeAt(0) !== 46) {
+        throw new Error("`extname` must start with `.`");
+      }
+      if (extname2.includes(".", 1)) {
+        throw new Error("`extname` cannot contain multiple dots");
+      }
+    }
+    this.path = path.join(this.dirname, this.stem + (extname2 || ""));
+  }
+  /**
+   * Get the stem (basename w/o extname) (example: `'index.min'`).
+   */
+  get stem() {
+    return typeof this.path === "string" ? path.basename(this.path, this.extname) : void 0;
+  }
+  /**
+   * Set the stem (basename w/o extname) (example: `'index.min'`).
+   *
+   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\'`
+   * on windows).
+   * Cannot be nullified (use `file.path = file.dirname` instead).
+   */
+  set stem(stem) {
+    assertNonEmpty(stem, "stem");
+    assertPart(stem, "stem");
+    this.path = path.join(this.dirname || "", stem + (this.extname || ""));
+  }
+  /**
+   * Serialize the file.
+   *
+   * @param {BufferEncoding | null | undefined} [encoding='utf8']
+   *   Character encoding to understand `value` as when it’s a `Buffer`
+   *   (default: `'utf8'`).
+   * @returns {string}
+   *   Serialized file.
+   */
+  toString(encoding) {
+    return (this.value || "").toString(encoding || void 0);
+  }
+  /**
+   * Create a warning message associated with the file.
+   *
+   * Its `fatal` is set to `false` and `file` is set to the current file path.
+   * Its added to `file.messages`.
+   *
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {VFileMessage}
+   *   Message.
+   */
+  message(reason, place, origin) {
+    const message = new VFileMessage(reason, place, origin);
+    if (this.path) {
+      message.name = this.path + ":" + message.name;
+      message.file = this.path;
+    }
+    message.fatal = false;
+    this.messages.push(message);
+    return message;
+  }
+  /**
+   * Create an info message associated with the file.
+   *
+   * Its `fatal` is set to `null` and `file` is set to the current file path.
+   * Its added to `file.messages`.
+   *
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {VFileMessage}
+   *   Message.
+   */
+  info(reason, place, origin) {
+    const message = this.message(reason, place, origin);
+    message.fatal = null;
+    return message;
+  }
+  /**
+   * Create a fatal error associated with the file.
+   *
+   * Its `fatal` is set to `true` and `file` is set to the current file path.
+   * Its added to `file.messages`.
+   *
+   * > 👉 **Note**: a fatal error means that a file is no longer processable.
+   *
+   * @param {string | Error | VFileMessage} reason
+   *   Reason for message, uses the stack and message of the error if given.
+   * @param {Node | NodeLike | Position | Point | null | undefined} [place]
+   *   Place in file where the message occurred.
+   * @param {string | null | undefined} [origin]
+   *   Place in code where the message originates (example:
+   *   `'my-package:my-rule'` or `'my-rule'`).
+   * @returns {never}
+   *   Message.
+   * @throws {VFileMessage}
+   *   Message.
+   */
+  fail(reason, place, origin) {
+    const message = this.message(reason, place, origin);
+    message.fatal = true;
+    throw message;
+  }
+};
+function assertPart(part, name) {
+  if (part && part.includes(path.sep)) {
+    throw new Error(
+      "`" + name + "` cannot be a path: did not expect `" + path.sep + "`"
+    );
+  }
+}
+function assertNonEmpty(part, name) {
+  if (!part) {
+    throw new Error("`" + name + "` cannot be empty");
+  }
+}
+function assertPath2(path2, name) {
+  if (!path2) {
+    throw new Error("Setting `" + name + "` requires `path` to be set too");
+  }
+}
+function buffer(value) {
+  return (0, import_is_buffer.default)(value);
+}
+
+// ../../node_modules/.pnpm/unified@10.1.2/node_modules/unified/lib/index.js
+var unified = base().freeze();
+var own = {}.hasOwnProperty;
+function base() {
+  const transformers = trough();
+  const attachers = [];
+  let namespace = {};
+  let frozen;
+  let freezeIndex = -1;
+  processor.data = data;
+  processor.Parser = void 0;
+  processor.Compiler = void 0;
+  processor.freeze = freeze;
+  processor.attachers = attachers;
+  processor.use = use;
+  processor.parse = parse;
+  processor.stringify = stringify;
+  processor.run = run;
+  processor.runSync = runSync;
+  processor.process = process;
+  processor.processSync = processSync;
+  return processor;
+  function processor() {
+    const destination = base();
+    let index2 = -1;
+    while (++index2 < attachers.length) {
+      destination.use(...attachers[index2]);
+    }
+    destination.data((0, import_extend.default)(true, {}, namespace));
+    return destination;
+  }
+  function data(key, value) {
+    if (typeof key === "string") {
+      if (arguments.length === 2) {
+        assertUnfrozen("data", frozen);
+        namespace[key] = value;
+        return processor;
+      }
+      return own.call(namespace, key) && namespace[key] || null;
+    }
+    if (key) {
+      assertUnfrozen("data", frozen);
+      namespace = key;
+      return processor;
+    }
+    return namespace;
+  }
+  function freeze() {
+    if (frozen) {
+      return processor;
+    }
+    while (++freezeIndex < attachers.length) {
+      const [attacher, ...options] = attachers[freezeIndex];
+      if (options[0] === false) {
+        continue;
+      }
+      if (options[0] === true) {
+        options[0] = void 0;
+      }
+      const transformer = attacher.call(processor, ...options);
+      if (typeof transformer === "function") {
+        transformers.use(transformer);
+      }
+    }
+    frozen = true;
+    freezeIndex = Number.POSITIVE_INFINITY;
+    return processor;
+  }
+  function use(value, ...options) {
+    let settings;
+    assertUnfrozen("use", frozen);
+    if (value === null || value === void 0) {
+    } else if (typeof value === "function") {
+      addPlugin(value, ...options);
+    } else if (typeof value === "object") {
+      if (Array.isArray(value)) {
+        addList(value);
+      } else {
+        addPreset(value);
+      }
+    } else {
+      throw new TypeError("Expected usable value, not `" + value + "`");
+    }
+    if (settings) {
+      namespace.settings = Object.assign(namespace.settings || {}, settings);
+    }
+    return processor;
+    function add(value2) {
+      if (typeof value2 === "function") {
+        addPlugin(value2);
+      } else if (typeof value2 === "object") {
+        if (Array.isArray(value2)) {
+          const [plugin, ...options2] = value2;
+          addPlugin(plugin, ...options2);
+        } else {
+          addPreset(value2);
+        }
+      } else {
+        throw new TypeError("Expected usable value, not `" + value2 + "`");
+      }
+    }
+    function addPreset(result) {
+      addList(result.plugins);
+      if (result.settings) {
+        settings = Object.assign(settings || {}, result.settings);
+      }
+    }
+    function addList(plugins) {
+      let index2 = -1;
+      if (plugins === null || plugins === void 0) {
+      } else if (Array.isArray(plugins)) {
+        while (++index2 < plugins.length) {
+          const thing = plugins[index2];
+          add(thing);
+        }
+      } else {
+        throw new TypeError("Expected a list of plugins, not `" + plugins + "`");
+      }
+    }
+    function addPlugin(plugin, value2) {
+      let index2 = -1;
+      let entry;
+      while (++index2 < attachers.length) {
+        if (attachers[index2][0] === plugin) {
+          entry = attachers[index2];
+          break;
+        }
+      }
+      if (entry) {
+        if (isPlainObject(entry[1]) && isPlainObject(value2)) {
+          value2 = (0, import_extend.default)(true, entry[1], value2);
+        }
+        entry[1] = value2;
+      } else {
+        attachers.push([...arguments]);
+      }
+    }
+  }
+  function parse(doc) {
+    processor.freeze();
+    const file = vfile(doc);
+    const Parser = processor.Parser;
+    assertParser("parse", Parser);
+    if (newable(Parser, "parse")) {
+      return new Parser(String(file), file).parse();
+    }
+    return Parser(String(file), file);
+  }
+  function stringify(node, doc) {
+    processor.freeze();
+    const file = vfile(doc);
+    const Compiler = processor.Compiler;
+    assertCompiler("stringify", Compiler);
+    assertNode(node);
+    if (newable(Compiler, "compile")) {
+      return new Compiler(node, file).compile();
+    }
+    return Compiler(node, file);
+  }
+  function run(node, doc, callback) {
+    assertNode(node);
+    processor.freeze();
+    if (!callback && typeof doc === "function") {
+      callback = doc;
+      doc = void 0;
+    }
+    if (!callback) {
+      return new Promise(executor);
+    }
+    executor(null, callback);
+    function executor(resolve, reject) {
+      transformers.run(node, vfile(doc), done);
+      function done(error, tree, file) {
+        tree = tree || node;
+        if (error) {
+          reject(error);
+        } else if (resolve) {
+          resolve(tree);
+        } else {
+          callback(null, tree, file);
+        }
+      }
+    }
+  }
+  function runSync(node, file) {
+    let result;
+    let complete;
+    processor.run(node, file, done);
+    assertDone("runSync", "run", complete);
+    return result;
+    function done(error, tree) {
+      bail(error);
+      result = tree;
+      complete = true;
+    }
+  }
+  function process(doc, callback) {
+    processor.freeze();
+    assertParser("process", processor.Parser);
+    assertCompiler("process", processor.Compiler);
+    if (!callback) {
+      return new Promise(executor);
+    }
+    executor(null, callback);
+    function executor(resolve, reject) {
+      const file = vfile(doc);
+      processor.run(processor.parse(file), file, (error, tree, file2) => {
+        if (error || !tree || !file2) {
+          done(error);
+        } else {
+          const result = processor.stringify(tree, file2);
+          if (result === void 0 || result === null) {
+          } else if (looksLikeAVFileValue(result)) {
+            file2.value = result;
+          } else {
+            file2.result = result;
+          }
+          done(error, file2);
+        }
+      });
+      function done(error, file2) {
+        if (error || !file2) {
+          reject(error);
+        } else if (resolve) {
+          resolve(file2);
+        } else {
+          callback(null, file2);
+        }
+      }
+    }
+  }
+  function processSync(doc) {
+    let complete;
+    processor.freeze();
+    assertParser("processSync", processor.Parser);
+    assertCompiler("processSync", processor.Compiler);
+    const file = vfile(doc);
+    processor.process(file, done);
+    assertDone("processSync", "process", complete);
+    return file;
+    function done(error) {
+      complete = true;
+      bail(error);
+    }
+  }
+}
+function newable(value, name) {
+  return typeof value === "function" && // Prototypes do exist.
+  // type-coverage:ignore-next-line
+  value.prototype && // A function with keys in its prototype is probably a constructor.
+  // Classes’ prototype methods are not enumerable, so we check if some value
+  // exists in the prototype.
+  // type-coverage:ignore-next-line
+  (keys(value.prototype) || name in value.prototype);
+}
+function keys(value) {
+  let key;
+  for (key in value) {
+    if (own.call(value, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+function assertParser(name, value) {
+  if (typeof value !== "function") {
+    throw new TypeError("Cannot `" + name + "` without `Parser`");
+  }
+}
+function assertCompiler(name, value) {
+  if (typeof value !== "function") {
+    throw new TypeError("Cannot `" + name + "` without `Compiler`");
+  }
+}
+function assertUnfrozen(name, frozen) {
+  if (frozen) {
+    throw new Error(
+      "Cannot call `" + name + "` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`."
+    );
+  }
+}
+function assertNode(node) {
+  if (!isPlainObject(node) || typeof node.type !== "string") {
+    throw new TypeError("Expected node, got `" + node + "`");
+  }
+}
+function assertDone(name, asyncName, complete) {
+  if (!complete) {
+    throw new Error(
+      "`" + name + "` finished async. Use `" + asyncName + "` instead"
+    );
+  }
+}
+function vfile(value) {
+  return looksLikeAVFile(value) ? value : new VFile(value);
+}
+function looksLikeAVFile(value) {
+  return Boolean(
+    value && typeof value === "object" && "message" in value && "messages" in value
+  );
+}
+function looksLikeAVFileValue(value) {
+  return typeof value === "string" || (0, import_is_buffer2.default)(value);
+}
+
+// src/useRemarkSync.ts
 import remarkParse from "remark-parse";
 import remarkToRehype from "remark-rehype";
 import rehypeReact from "rehype-react";
@@ -329,10 +1513,53 @@ var useRemarkSync = (source, {
   Fragment: Fragment3
 }, rehypeReactOptions)).processSync(source).result;
 
+// src/useToc.ts
+import remarkParse2 from "remark-parse";
+import remarkStringify from "remark-stringify";
+
+// src/remarkHeadings.ts
+import { visit as visit3 } from "unist-util-visit";
+import { toString } from "mdast-util-to-string";
+var getAnchor = (heading) => {
+  var _a;
+  if ((_a = heading == null ? void 0 : heading.data) == null ? void 0 : _a.id) {
+    return heading.data.id;
+  }
+  let anchor = toString(heading, { includeImageAlt: false }).toLowerCase();
+  anchor = anchor.replace(/[^a-zA-Z0-9 ]/g, "");
+  anchor = anchor.replace(/ /g, "-");
+  return anchor;
+};
+var headings = (root) => {
+  const headingList = [];
+  visit3(root, "heading", (node) => {
+    const heading = {
+      level: node.depth,
+      label: toString(node, { includeImageAlt: false }),
+      anchor: getAnchor(node)
+    };
+    headingList.push(heading);
+  });
+  return headingList;
+};
+var remarkHeadings = () => {
+  return (tree, file) => {
+    file.data.headings = headings(tree);
+  };
+};
+
+// src/useToc.ts
+var useToc = (markdown) => {
+  return unified().use(remarkCustomHeadingIds).use(remarkParse2).use(remarkStringify).use(remarkHeadings).processSync(markdown).data.headings;
+};
+
 // src/Markdown.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
-var Markdown = ({ children }) => {
+import { Fragment as Fragment4, useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var Markdown = ({ children, showToc = true }) => {
   const directives = useDirectives2();
+  const toc = useToc(children);
+  const [isTocOpen, setIsTocOpen] = useState4(false);
   const reactContent = useRemarkSync(children, {
     rehypeReactOptions: {
       passNode: true,
@@ -367,9 +1594,47 @@ var Markdown = ({ children }) => {
       [rehypeHighlight, { ignoreMissing: true, plainText: ["mermaid"] }]
     ]
   });
-  return /* @__PURE__ */ jsx6("div", { className: "hyperbook-markdown", children: reactContent });
+  return /* @__PURE__ */ jsxs4("div", { className: "hyperbook-markdown", children: [
+    showToc && /* @__PURE__ */ jsxs4(Fragment4, { children: [
+      /* @__PURE__ */ jsxs4(
+        "button",
+        {
+          className: isTocOpen ? "toc-toggle open" : "toc-toggle",
+          onClick: () => setIsTocOpen(!isTocOpen),
+          title: "Table of Contents",
+          children: [
+            /* @__PURE__ */ jsx6("div", { className: "bar1" }),
+            /* @__PURE__ */ jsx6("div", { className: "bar2" }),
+            /* @__PURE__ */ jsx6("div", { className: "bar3" }),
+            /* @__PURE__ */ jsx6("div", { className: "bar4" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx6(
+        Drawer,
+        {
+          isOpen: isTocOpen,
+          onClose: () => setIsTocOpen(false),
+          position: "right",
+          children: /* @__PURE__ */ jsx6("div", { id: "toc-sidebar", children: /* @__PURE__ */ jsx6("nav", { className: "toc", children: /* @__PURE__ */ jsx6("ul", { children: toc.map((h, i) => /* @__PURE__ */ jsx6("li", { className: `level-${h.level}`, children: /* @__PURE__ */ jsx6("a", { href: `#${h.anchor}`, children: h.label }) }, i)) }) }) })
+        }
+      )
+    ] }),
+    reactContent
+  ] });
 };
 export {
-  Markdown
+  Markdown,
+  useToc
 };
+/*! Bundled license information:
+
+is-buffer/index.js:
+  (*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/
 //# sourceMappingURL=index.esm.mjs.map