@lvce-editor/static-server 0.54.0 → 0.54.2

package/static/05e6417/packages/markdown-worker/dist/markdownWorkerMain.js

@@ -1,3906 +0,0 @@
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-}
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const array = value => {
-  const type = getType(value);
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
-};
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
-};
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
-};
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
-    }
-  }
-  return false;
-};
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
-};
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
-  }
-}
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
-};
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
-};
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines$1(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
-};
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
-};
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
-};
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines$1(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
-  const relevantLines = lines.slice(startIndex, endIndex);
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
-  return relevantMessage;
-};
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
-};
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: actualMessage,
-    code: '',
-    stack: rest
-  };
-};
-class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-  }
-}
-const readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
-};
-const listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$8 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-}
-const wrap$f = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const withResolvers = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    resolve: _resolve,
-    promise
-  };
-};
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$8(parentIpcRaw);
-  const parentIpc = wrap$f(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
-};
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$e = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$e
-};
-
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get = id => {
-  return callbacks[id];
-};
-const remove = id => {
-  delete callbacks[id];
-};
-let id = 0;
-const create$3 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
-  }
-}
-const NewLine = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
-  }
-  return parentStack;
-};
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
-  }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
-};
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
-  }
-  throw new JsonRpcError('unexpected response message');
-};
-const warn = (...args) => {
-  console.warn(...args);
-};
-const resolve = (id, response) => {
-  const fn = get(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove(id);
-};
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
-  }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
-  }
-  return undefined;
-};
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
-};
-const create$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
-};
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
-};
-const create$5 = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
-};
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
-  }
-};
-const defaultPreparePrettyError = error => {
-  return error;
-};
-const defaultLogError = () => {
-  // ignore
-};
-const defaultRequiresSocket = () => {
-  return false;
-};
-const defaultResolve = resolve;
-
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    const options = args[0];
-    return {
-      ipc: options.ipc,
-      message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
-    };
-  }
-  return {
-    ipc: args[0],
-    message: args[1],
-    execute: args[2],
-    resolve: args[3],
-    preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
-  };
-};
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    message,
-    ipc,
-    execute,
-    resolve,
-    preparePrettyError,
-    logError,
-    requiresSocket
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
-  }
-  throw new JsonRpcError('unexpected message');
-};
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`command not found ${command}`);
-  }
-  return fn(...args);
-};
-
-const createRpc = ipc => {
-  const rpc = {
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
-    }
-  };
-  return rpc;
-};
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError = () => {
-  // handled by renderer worker
-};
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
-};
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
-};
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-const create = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create
-};
-
-const allowedMarkdownAttributes = ['src', 'id', 'className', 'title', 'alt', 'href', 'target', 'rel'];
-
-const Document = 'document';
-
-const Markdown = 'Markdown';
-
-const HandleReadmeContextMenu = 'handleReadmeContextMenu';
-
-const getVirtualDomChildCount = markdownDom => {
-  const max = markdownDom.length - 1;
-  let stack = [];
-  for (let i = max; i >= 0; i--) {
-    const element = markdownDom[i];
-    if (element.childCount > 0) {
-      stack = stack.slice(element.childCount);
-    }
-    stack.unshift(element);
-  }
-  return stack.length;
-};
-
-const Div$1 = 'div';
-const H1$1 = 'h1';
-const H2$1 = 'h2';
-const H3$1 = 'h3';
-const H4$1 = 'h4';
-const H5$1 = 'h5';
-const Img$1 = 'img';
-const Span$1 = 'span';
-const Article$1 = 'article';
-const Aside$1 = 'aside';
-const Footer$1 = 'footer';
-const Header$1 = 'header';
-const Nav$1 = 'nav';
-const Section$1 = 'section';
-const Search$1 = 'search';
-const Dd$1 = 'dd';
-const Dl$1 = 'dl';
-const Figcaption$1 = 'figcaption';
-const Figure$1 = 'figure';
-const Hr$1 = 'hr';
-const Li$1 = 'li';
-const Ol$1 = 'ol';
-const P$1 = 'p';
-const Pre$1 = 'pre';
-const A$1 = 'a';
-const Abbr$1 = 'abbr';
-const Br$1 = 'br';
-const Cite$1 = 'cite';
-const Data$1 = 'data';
-const Time$1 = 'time';
-const Tfoot$1 = 'tfoot';
-
-const A = 53;
-const Abbr = 54;
-const Article = 27;
-const Aside = 28;
-const Br = 55;
-const Cite = 56;
-const Data = 57;
-const Dd = 43;
-const Div = 4;
-const Dl = 44;
-const Figcaption = 45;
-const Figure = 46;
-const Footer = 29;
-const H1 = 5;
-const H2 = 22;
-const H3 = 23;
-const H4 = 24;
-const H5 = 25;
-const Header = 30;
-const Hr = 47;
-const Img = 17;
-const Li = 48;
-const Nav = 40;
-const Ol = 49;
-const P = 50;
-const Pre = 51;
-const Search = 42;
-const Section = 41;
-const Span = 8;
-const Text$1 = 12;
-const Tfoot = 59;
-const Time = 58;
-
-const getVirtualDomTag = text => {
-  switch (text) {
-    case H1$1:
-      return H1;
-    case H2$1:
-      return H2;
-    case H3$1:
-      return H3;
-    case H4$1:
-      return H4;
-    case H5$1:
-      return H5;
-    case Div$1:
-      return Div;
-    case Article$1:
-      return Article;
-    case Aside$1:
-      return Aside;
-    case Footer$1:
-      return Footer;
-    case Header$1:
-      return Header;
-    case Nav$1:
-      return Nav;
-    case Section$1:
-      return Section;
-    case Search$1:
-      return Search;
-    case Dd$1:
-      return Dd;
-    case Dl$1:
-      return Dl;
-    case Figcaption$1:
-      return Figcaption;
-    case Figure$1:
-      return Figure;
-    case Hr$1:
-      return Hr;
-    case Li$1:
-      return Li;
-    case Ol$1:
-      return Ol;
-    case P$1:
-      return P;
-    case Pre$1:
-      return Pre;
-    case A$1:
-      return A;
-    case Abbr$1:
-      return Abbr;
-    case Br$1:
-      return Br;
-    case Cite$1:
-      return Cite;
-    case Data$1:
-      return Data;
-    case Time$1:
-      return Time;
-    case Tfoot$1:
-      return Tfoot;
-    case Img$1:
-      return Img;
-    case Span$1:
-      return Span;
-    default:
-      return Div;
-  }
-};
-
-const None = 0;
-const OpeningAngleBracket = 1;
-const ClosingAngleBracket = 2;
-const TagNameStart = 3;
-const TagNameEnd = 4;
-const Content = 5;
-const ClosingTagSlash = 6;
-const WhitespaceInsideOpeningTag = 7;
-const AttributeName = 8;
-const AttributeEqualSign = 9;
-const AttributeQuoteStart = 10;
-const AttributeValue = 11;
-const AttributeQuoteEnd = 12;
-const WhitespaceAfterClosingTagSlash = 13;
-const WhitespaceAfterOpeningTagOpenAngleBracket = 14;
-const ExclamationMark = 15;
-const Doctype = 16;
-const StartCommentDashes = 17;
-const Comment = 18;
-const EndCommentTag = 19;
-const Text = 20;
-const CommentStart = 21;
-
-const isSelfClosingTag = tag => {
-  switch (tag) {
-    case Img$1:
-      return true;
-    default:
-      return false;
-  }
-};
-
-const parseText = text => {
-  return text.replaceAll('&gt;', '>').replaceAll('&lt;', '<').replaceAll('&amp;', '&');
-};
-
-class UnexpectedTokenError extends Error {
-  constructor() {
-    super('Unexpected token');
-    this.name = 'UnexpectedTokenError';
-  }
-}
-
-const State = {
-  TopLevelContent: 1,
-  AfterOpeningAngleBracket: 2,
-  InsideOpeningTag: 3,
-  AfterClosingTagSlash: 4,
-  AfterClosingTagName: 5,
-  InsideOpeningTagAfterWhitespace: 6,
-  AfterAttributeName: 7,
-  AfterAttributeEqualSign: 8,
-  InsideAttributeAfterDoubleQuote: 9,
-  AfterAttributeValueInsideDoubleQuote: 10,
-  AfterAttributeValueClosingQuote: 11,
-  AfterExclamationMark: 16,
-  InsideComment: 17
-};
-const RE_ANGLE_BRACKET_OPEN = /^</;
-const RE_ANGLE_BRACKET_OPEN_TAG = /^<(?![\s!%])/;
-const RE_ANGLE_BRACKET_CLOSE = /^>/;
-const RE_SLASH = /^\//;
-const RE_TAGNAME = /^[a-zA-Z\d$]+/;
-const RE_CONTENT = /^[^<>]+/;
-const RE_WHITESPACE = /^\s+/;
-const RE_ATTRIBUTE_NAME = /^[a-zA-Z\d-]+/;
-const RE_EQUAL_SIGN = /^=/;
-const RE_DOUBLE_QUOTE = /^"/;
-const RE_ATTRIBUTE_VALUE_INSIDE_DOUBLE_QUOTE = /^[^"\n]+/;
-const RE_TEXT = /^[^<>]+/;
-const RE_EXCLAMATION_MARK = /^!/;
-const RE_DASH_DASH = /^--/;
-const RE_DOCTYPE = /^doctype/i;
-const RE_BLOCK_COMMENT_CONTENT = /^[a-zA-Z\s]+/;
-const RE_COMMENT_END = /^-->/;
-const RE_TAG_TEXT = /^[^\s>]+/;
-const RE_ANY_TEXT = /^[^\n]+/;
-const RE_BLOCK_COMMENT_START = /^<!--/;
-const RE_SELF_CLOSING = /^\/>/;
-const tokenizeHtml = text => {
-  string(text);
-  let state = State.TopLevelContent;
-  let index = 0;
-  let next;
-  const tokens = [];
-  let token = None;
-  while (index < text.length) {
-    const part = text.slice(index);
-    switch (state) {
-      case State.TopLevelContent:
-        if (next = part.match(RE_ANGLE_BRACKET_OPEN_TAG)) {
-          token = OpeningAngleBracket;
-          state = State.AfterOpeningAngleBracket;
-        } else if (next = part.match(RE_CONTENT)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_BLOCK_COMMENT_START)) {
-          token = CommentStart;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_OPEN)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterOpeningAngleBracket:
-        if (next = part.match(RE_TAGNAME)) {
-          token = TagNameStart;
-          state = State.InsideOpeningTag;
-        } else if (next = part.match(RE_SLASH)) {
-          token = ClosingTagSlash;
-          state = State.AfterClosingTagSlash;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceAfterOpeningTagOpenAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_EXCLAMATION_MARK)) {
-          token = ExclamationMark;
-          state = State.AfterExclamationMark;
-        } else if (next = part.match(RE_ANY_TEXT)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterExclamationMark:
-        if (next = part.match(RE_DASH_DASH)) {
-          token = StartCommentDashes;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_DOCTYPE)) {
-          token = Doctype;
-          state = State.InsideOpeningTag;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideComment:
-        if (next = part.match(RE_BLOCK_COMMENT_CONTENT)) {
-          token = Comment;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_COMMENT_END)) {
-          token = EndCommentTag;
-          state = State.TopLevelContent;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideOpeningTag:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_TAG_TEXT)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideOpeningTagAfterWhitespace:
-        if (next = part.match(RE_ATTRIBUTE_NAME)) {
-          token = AttributeName;
-          state = State.AfterAttributeName;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_SELF_CLOSING)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_TEXT)) {
-          token = AttributeName;
-          state = State.AfterAttributeName;
-        } else {
-          text.slice(index).match(RE_TEXT); // ?
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeName:
-        if (next = part.match(RE_EQUAL_SIGN)) {
-          token = AttributeEqualSign;
-          state = State.AfterAttributeEqualSign;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_ANGLE_BRACKET_OPEN)) {
-          token = OpeningAngleBracket;
-          state = State.AfterOpeningAngleBracket;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeEqualSign:
-        if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteStart;
-          state = State.InsideAttributeAfterDoubleQuote;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideAttributeAfterDoubleQuote:
-        if (next = text.slice(index).match(RE_ATTRIBUTE_VALUE_INSIDE_DOUBLE_QUOTE)) {
-          token = AttributeValue;
-          state = State.AfterAttributeValueInsideDoubleQuote;
-        } else if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeValueInsideDoubleQuote:
-        if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeValueClosingQuote:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_SELF_CLOSING)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterClosingTagSlash:
-        if (next = part.match(RE_TAGNAME)) {
-          token = TagNameEnd;
-          state = State.AfterClosingTagName;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceAfterClosingTagSlash;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterClosingTagName:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      default:
-        throw new UnexpectedTokenError();
-    }
-    const tokenText = next[0];
-    tokens.push({
-      type: token,
-      text: tokenText
-    });
-    index += tokenText.length;
-  }
-  return tokens;
-};
-
-const text = data => {
-  return {
-    type: Text$1,
-    text: data,
-    childCount: 0
-  };
-};
-
-const parseHtml = (html, allowedAttributes) => {
-  string(html);
-  array(allowedAttributes);
-  const tokens = tokenizeHtml(html);
-  const dom = [];
-  const root = {
-    type: 0,
-    childCount: 0
-  };
-  let current = root;
-  const stack = [root];
-  let attributeName = '';
-  for (const token of tokens) {
-    switch (token.type) {
-      case TagNameStart:
-        current.childCount++;
-        current = {
-          type: getVirtualDomTag(token.text),
-          childCount: 0
-        };
-        dom.push(current);
-        if (!isSelfClosingTag(token.text)) {
-          stack.push(current);
-        }
-        break;
-      case TagNameEnd:
-        stack.pop();
-        current = stack.at(-1) || root;
-        break;
-      case Content:
-        current.childCount++;
-        dom.push(text(parseText(token.text)));
-        break;
-      case AttributeName:
-        attributeName = token.text;
-        if (attributeName === 'class') {
-          attributeName = 'className';
-        }
-        break;
-      case AttributeValue:
-        if (allowedAttributes.includes(attributeName)) {
-          current[attributeName] = token.text;
-        }
-        attributeName = '';
-        break;
-    }
-  }
-  return dom;
-};
-
-const getMarkdownVirtualDom = html => {
-  string(html);
-  const childDom = parseHtml(html, allowedMarkdownAttributes);
-  const markdownChildCount = getVirtualDomChildCount(childDom);
-  return [{
-    type: Div,
-    className: Markdown,
-    role: Document,
-    onContextMenu: HandleReadmeContextMenu,
-    childCount: markdownChildCount
-  }, ...childDom];
-};
-
-/**
- * marked v15.0.9 - a markdown parser
- * Copyright (c) 2011-2025, Christopher Jeffrey. (MIT Licensed)
- * https://github.com/markedjs/marked
- */
-
-/**
- * DO NOT EDIT THIS FILE
- * The code in this file is generated from files in ./src/
- */
-
-/**
- * Gets the original marked default options.
- */
-function _getDefaults() {
-  return {
-    async: false,
-    breaks: false,
-    extensions: null,
-    gfm: true,
-    hooks: null,
-    pedantic: false,
-    renderer: null,
-    silent: false,
-    tokenizer: null,
-    walkTokens: null
-  };
-}
-let _defaults = _getDefaults();
-function changeDefaults(newDefaults) {
-  _defaults = newDefaults;
-}
-const noopTest = {
-  exec: () => null
-};
-function edit(regex, opt = '') {
-  let source = typeof regex === 'string' ? regex : regex.source;
-  const obj = {
-    replace: (name, val) => {
-      let valSource = typeof val === 'string' ? val : val.source;
-      valSource = valSource.replace(other.caret, '$1');
-      source = source.replace(name, valSource);
-      return obj;
-    },
-    getRegex: () => {
-      return new RegExp(source, opt);
-    }
-  };
-  return obj;
-}
-const other = {
-  codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm,
-  outputLinkReplace: /\\([\[\]])/g,
-  indentCodeCompensation: /^(\s+)(?:```)/,
-  beginningSpace: /^\s+/,
-  endingHash: /#$/,
-  startingSpaceChar: /^ /,
-  endingSpaceChar: / $/,
-  nonSpaceChar: /[^ ]/,
-  newLineCharGlobal: /\n/g,
-  tabCharGlobal: /\t/g,
-  multipleSpaceGlobal: /\s+/g,
-  blankLine: /^[ \t]*$/,
-  doubleBlankLine: /\n[ \t]*\n[ \t]*$/,
-  blockquoteStart: /^ {0,3}>/,
-  blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g,
-  blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm,
-  listReplaceTabs: /^\t+/,
-  listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g,
-  listIsTask: /^\[[ xX]\] /,
-  listReplaceTask: /^\[[ xX]\] +/,
-  anyLine: /\n.*\n/,
-  hrefBrackets: /^<(.*)>$/,
-  tableDelimiter: /[:|]/,
-  tableAlignChars: /^\||\| *$/g,
-  tableRowBlankLine: /\n[ \t]*$/,
-  tableAlignRight: /^ *-+: *$/,
-  tableAlignCenter: /^ *:-+: *$/,
-  tableAlignLeft: /^ *:-+ *$/,
-  startATag: /^<a /i,
-  endATag: /^<\/a>/i,
-  startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i,
-  endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i,
-  startAngleBracket: /^</,
-  endAngleBracket: />$/,
-  pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/,
-  unicodeAlphaNumeric: /[\p{L}\p{N}]/u,
-  escapeTest: /[&<>"']/,
-  escapeReplace: /[&<>"']/g,
-  escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,
-  escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,
-  unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig,
-  caret: /(^|[^\[])\^/g,
-  percentDecode: /%25/g,
-  findPipe: /\|/g,
-  splitPipe: / \|/,
-  slashPipe: /\\\|/g,
-  carriageReturn: /\r\n|\r/g,
-  spaceLine: /^ +$/gm,
-  notSpaceStart: /^\S*/,
-  endingNewline: /\n$/,
-  listItemRegex: bull => new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`),
-  nextBulletRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),
-  hrRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),
-  fencesBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`),
-  headingBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`),
-  htmlBeginRegex: indent => new RegExp(`^ {0,${Math.min(3, indent - 1)}}<(?:[a-z].*>|!--)`, 'i')
-};
-/**
- * Block-Level Grammar
- */
-const newline = /^(?:[ \t]*(?:\n|$))+/;
-const blockCode = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
-const fences = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
-const hr = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
-const heading = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
-const bullet = /(?:[*+-]|\d{1,9}[.)])/;
-const lheadingCore = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
-const lheading = edit(lheadingCore).replace(/bull/g, bullet) // lists can interrupt
-.replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
-.replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
-.replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
-.replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
-.replace(/html/g, / {0,3}<[^\n>]+>\n/) // block html can interrupt
-.replace(/\|table/g, '') // table not in commonmark
-.getRegex();
-const lheadingGfm = edit(lheadingCore).replace(/bull/g, bullet) // lists can interrupt
-.replace(/blockCode/g, /(?: {4}| {0,3}\t)/) // indented code blocks can interrupt
-.replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/) // fenced code blocks can interrupt
-.replace(/blockquote/g, / {0,3}>/) // blockquote can interrupt
-.replace(/heading/g, / {0,3}#{1,6}/) // ATX heading can interrupt
-.replace(/html/g, / {0,3}<[^\n>]+>\n/) // block html can interrupt
-.replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/) // table can interrupt
-.getRegex();
-const _paragraph = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/;
-const blockText = /^[^\n]+/;
-const _blockLabel = /(?!\s*\])(?:\\.|[^\[\]\\])+/;
-const def = edit(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace('label', _blockLabel).replace('title', /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
-const list = edit(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, bullet).getRegex();
-const _tag = 'address|article|aside|base|basefont|blockquote|body|caption' + '|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption' + '|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe' + '|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option' + '|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title' + '|tr|track|ul';
-const _comment = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
-const html = edit('^ {0,3}(?:' // optional indentation
-+ '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
-+ '|comment[^\\n]*(\\n+|$)' // (2)
-+ '|<\\?[\\s\\S]*?(?:\\?>\\n*|$)' // (3)
-+ '|<![A-Z][\\s\\S]*?(?:>\\n*|$)' // (4)
-+ '|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)' // (5)
-+ '|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (6)
-+ '|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) open tag
-+ '|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)' // (7) closing tag
-+ ')', 'i').replace('comment', _comment).replace('tag', _tag).replace('attribute', / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
-const paragraph = edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
-.replace('|table', '').replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-.replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
-.getRegex();
-const blockquote = edit(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace('paragraph', paragraph).getRegex();
-/**
- * Normal Block Grammar
- */
-const blockNormal = {
-  blockquote,
-  code: blockCode,
-  def,
-  fences,
-  heading,
-  hr,
-  html,
-  lheading,
-  list,
-  newline,
-  paragraph,
-  table: noopTest,
-  text: blockText
-};
-/**
- * GFM Block Grammar
- */
-const gfmTable = edit('^ *([^\\n ].*)\\n' // Header
-+ ' {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)' // Align
-+ '(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)') // Cells
-.replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('blockquote', ' {0,3}>').replace('code', '(?: {4}| {0,3}\t)[^\\n]').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-.replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // tables can be interrupted by type (6) html blocks
-.getRegex();
-const blockGfm = {
-  ...blockNormal,
-  lheading: lheadingGfm,
-  table: gfmTable,
-  paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' {0,3}#{1,6}(?:\\s|$)').replace('|lheading', '') // setext headings don't interrupt commonmark paragraphs
-  .replace('table', gfmTable) // interrupt paragraphs with table
-  .replace('blockquote', ' {0,3}>').replace('fences', ' {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n').replace('list', ' {0,3}(?:[*+-]|1[.)]) ') // only lists starting from 1 can interrupt
-  .replace('html', '</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)').replace('tag', _tag) // pars can be interrupted by type (6) html blocks
-  .getRegex()
-};
-/**
- * Pedantic grammar (original John Gruber's loose markdown specification)
- */
-const blockPedantic = {
-  ...blockNormal,
-  html: edit('^ *(?:comment *(?:\\n|\\s*$)' + '|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)' // closed tag
-  + '|<tag(?:"[^"]*"|\'[^\']*\'|\\s[^\'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))').replace('comment', _comment).replace(/tag/g, '(?!(?:' + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub' + '|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)' + '\\b)\\w+(?!:|[^\\w\\s@]*@)\\b').getRegex(),
-  def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,
-  heading: /^(#{1,6})(.*)(?:\n+|$)/,
-  fences: noopTest,
-  // fences not supported
-  lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,
-  paragraph: edit(_paragraph).replace('hr', hr).replace('heading', ' *#{1,6} *[^\n]').replace('lheading', lheading).replace('|table', '').replace('blockquote', ' {0,3}>').replace('|fences', '').replace('|list', '').replace('|html', '').replace('|tag', '').getRegex()
-};
-/**
- * Inline-Level Grammar
- */
-const escape$1 = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
-const inlineCode = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
-const br = /^( {2,}|\\)\n(?!\s*$)/;
-const inlineText = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
-// list of unicode punctuation marks, plus any missing characters from CommonMark spec
-const _punctuation = /[\p{P}\p{S}]/u;
-const _punctuationOrSpace = /[\s\p{P}\p{S}]/u;
-const _notPunctuationOrSpace = /[^\s\p{P}\p{S}]/u;
-const punctuation = edit(/^((?![*_])punctSpace)/, 'u').replace(/punctSpace/g, _punctuationOrSpace).getRegex();
-// GFM allows ~ inside strong and em for strikethrough
-const _punctuationGfmStrongEm = /(?!~)[\p{P}\p{S}]/u;
-const _punctuationOrSpaceGfmStrongEm = /(?!~)[\s\p{P}\p{S}]/u;
-const _notPunctuationOrSpaceGfmStrongEm = /(?:[^\s\p{P}\p{S}]|~)/u;
-// sequences em should skip over [title](link), `code`, <html>
-const blockSkip = /\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g;
-const emStrongLDelimCore = /^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/;
-const emStrongLDelim = edit(emStrongLDelimCore, 'u').replace(/punct/g, _punctuation).getRegex();
-const emStrongLDelimGfm = edit(emStrongLDelimCore, 'u').replace(/punct/g, _punctuationGfmStrongEm).getRegex();
-const emStrongRDelimAstCore = '^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)' // Skip orphan inside strong
-+ '|[^*]+(?=[^*])' // Consume to delim
-+ '|(?!\\*)punct(\\*+)(?=[\\s]|$)' // (1) #*** can only be a Right Delimiter
-+ '|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)' // (2) a***#, a*** can only be a Right Delimiter
-+ '|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)' // (3) #***a, ***a can only be Left Delimiter
-+ '|[\\s](\\*+)(?!\\*)(?=punct)' // (4) ***# can only be Left Delimiter
-+ '|(?!\\*)punct(\\*+)(?!\\*)(?=punct)' // (5) #***# can be either Left or Right Delimiter
-+ '|notPunctSpace(\\*+)(?=notPunctSpace)'; // (6) a***a can be either Left or Right Delimiter
-const emStrongRDelimAst = edit(emStrongRDelimAstCore, 'gu').replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
-const emStrongRDelimAstGfm = edit(emStrongRDelimAstCore, 'gu').replace(/notPunctSpace/g, _notPunctuationOrSpaceGfmStrongEm).replace(/punctSpace/g, _punctuationOrSpaceGfmStrongEm).replace(/punct/g, _punctuationGfmStrongEm).getRegex();
-// (6) Not allowed for _
-const emStrongRDelimUnd = edit('^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)' // Skip orphan inside strong
-+ '|[^_]+(?=[^_])' // Consume to delim
-+ '|(?!_)punct(_+)(?=[\\s]|$)' // (1) #___ can only be a Right Delimiter
-+ '|notPunctSpace(_+)(?!_)(?=punctSpace|$)' // (2) a___#, a___ can only be a Right Delimiter
-+ '|(?!_)punctSpace(_+)(?=notPunctSpace)' // (3) #___a, ___a can only be Left Delimiter
-+ '|[\\s](_+)(?!_)(?=punct)' // (4) ___# can only be Left Delimiter
-+ '|(?!_)punct(_+)(?!_)(?=punct)', 'gu') // (5) #___# can be either Left or Right Delimiter
-.replace(/notPunctSpace/g, _notPunctuationOrSpace).replace(/punctSpace/g, _punctuationOrSpace).replace(/punct/g, _punctuation).getRegex();
-const anyPunctuation = edit(/\\(punct)/, 'gu').replace(/punct/g, _punctuation).getRegex();
-const autolink = edit(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace('scheme', /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace('email', /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
-const _inlineComment = edit(_comment).replace('(?:-->|$)', '-->').getRegex();
-const tag = edit('^comment' + '|^</[a-zA-Z][\\w:-]*\\s*>' // self-closing tag
-+ '|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>' // open tag
-+ '|^<\\?[\\s\\S]*?\\?>' // processing instruction, e.g. <?php ?>
-+ '|^<![a-zA-Z]+\\s[\\s\\S]*?>' // declaration, e.g. <!DOCTYPE html>
-+ '|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>') // CDATA section
-.replace('comment', _inlineComment).replace('attribute', /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
-const _inlineLabel = /(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/;
-const link = edit(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace('label', _inlineLabel).replace('href', /<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace('title', /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
-const reflink = edit(/^!?\[(label)\]\[(ref)\]/).replace('label', _inlineLabel).replace('ref', _blockLabel).getRegex();
-const nolink = edit(/^!?\[(ref)\](?:\[\])?/).replace('ref', _blockLabel).getRegex();
-const reflinkSearch = edit('reflink|nolink(?!\\()', 'g').replace('reflink', reflink).replace('nolink', nolink).getRegex();
-/**
- * Normal Inline Grammar
- */
-const inlineNormal = {
-  _backpedal: noopTest,
-  // only used for GFM url
-  anyPunctuation,
-  autolink,
-  blockSkip,
-  br,
-  code: inlineCode,
-  del: noopTest,
-  emStrongLDelim,
-  emStrongRDelimAst,
-  emStrongRDelimUnd,
-  escape: escape$1,
-  link,
-  nolink,
-  punctuation,
-  reflink,
-  reflinkSearch,
-  tag,
-  text: inlineText,
-  url: noopTest
-};
-/**
- * Pedantic Inline Grammar
- */
-const inlinePedantic = {
-  ...inlineNormal,
-  link: edit(/^!?\[(label)\]\((.*?)\)/).replace('label', _inlineLabel).getRegex(),
-  reflink: edit(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace('label', _inlineLabel).getRegex()
-};
-/**
- * GFM Inline Grammar
- */
-const inlineGfm = {
-  ...inlineNormal,
-  emStrongRDelimAst: emStrongRDelimAstGfm,
-  emStrongLDelim: emStrongLDelimGfm,
-  url: edit(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/, 'i').replace('email', /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),
-  _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,
-  del: /^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,
-  text: /^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/
-};
-/**
- * GFM + Line Breaks Inline Grammar
- */
-const inlineBreaks = {
-  ...inlineGfm,
-  br: edit(br).replace('{2,}', '*').getRegex(),
-  text: edit(inlineGfm.text).replace('\\b_', '\\b_| {2,}\\n').replace(/\{2,\}/g, '*').getRegex()
-};
-/**
- * exports
- */
-const block = {
-  normal: blockNormal,
-  gfm: blockGfm,
-  pedantic: blockPedantic
-};
-const inline = {
-  normal: inlineNormal,
-  gfm: inlineGfm,
-  breaks: inlineBreaks,
-  pedantic: inlinePedantic
-};
-
-/**
- * Helpers
- */
-const escapeReplacements = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;'
-};
-const getEscapeReplacement = ch => escapeReplacements[ch];
-function escape(html, encode) {
-  if (encode) {
-    if (other.escapeTest.test(html)) {
-      return html.replace(other.escapeReplace, getEscapeReplacement);
-    }
-  } else {
-    if (other.escapeTestNoEncode.test(html)) {
-      return html.replace(other.escapeReplaceNoEncode, getEscapeReplacement);
-    }
-  }
-  return html;
-}
-function cleanUrl(href) {
-  try {
-    href = encodeURI(href).replace(other.percentDecode, '%');
-  } catch {
-    return null;
-  }
-  return href;
-}
-function splitCells(tableRow, count) {
-  // ensure that every cell-delimiting pipe has a space
-  // before it to distinguish it from an escaped pipe
-  const row = tableRow.replace(other.findPipe, (match, offset, str) => {
-      let escaped = false;
-      let curr = offset;
-      while (--curr >= 0 && str[curr] === '\\') escaped = !escaped;
-      if (escaped) {
-        // odd number of slashes means | is escaped
-        // so we leave it alone
-        return '|';
-      } else {
-        // add space before unescaped |
-        return ' |';
-      }
-    }),
-    cells = row.split(other.splitPipe);
-  let i = 0;
-  // First/last cell in a row cannot be empty if it has no leading/trailing pipe
-  if (!cells[0].trim()) {
-    cells.shift();
-  }
-  if (cells.length > 0 && !cells.at(-1)?.trim()) {
-    cells.pop();
-  }
-  if (count) {
-    if (cells.length > count) {
-      cells.splice(count);
-    } else {
-      while (cells.length < count) cells.push('');
-    }
-  }
-  for (; i < cells.length; i++) {
-    // leading or trailing whitespace is ignored per the gfm spec
-    cells[i] = cells[i].trim().replace(other.slashPipe, '|');
-  }
-  return cells;
-}
-/**
- * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
- * /c*$/ is vulnerable to REDOS.
- *
- * @param str
- * @param c
- * @param invert Remove suffix of non-c chars instead. Default falsey.
- */
-function rtrim(str, c, invert) {
-  const l = str.length;
-  if (l === 0) {
-    return '';
-  }
-  // Length of suffix matching the invert condition.
-  let suffLen = 0;
-  // Step left until we fail to match the invert condition.
-  while (suffLen < l) {
-    const currChar = str.charAt(l - suffLen - 1);
-    if (currChar === c && true) {
-      suffLen++;
-    } else {
-      break;
-    }
-  }
-  return str.slice(0, l - suffLen);
-}
-function findClosingBracket(str, b) {
-  if (str.indexOf(b[1]) === -1) {
-    return -1;
-  }
-  let level = 0;
-  for (let i = 0; i < str.length; i++) {
-    if (str[i] === '\\') {
-      i++;
-    } else if (str[i] === b[0]) {
-      level++;
-    } else if (str[i] === b[1]) {
-      level--;
-      if (level < 0) {
-        return i;
-      }
-    }
-  }
-  if (level > 0) {
-    return -2;
-  }
-  return -1;
-}
-function outputLink(cap, link, raw, lexer, rules) {
-  const href = link.href;
-  const title = link.title || null;
-  const text = cap[1].replace(rules.other.outputLinkReplace, '$1');
-  if (cap[0].charAt(0) !== '!') {
-    lexer.state.inLink = true;
-    const token = {
-      type: 'link',
-      raw,
-      href,
-      title,
-      text,
-      tokens: lexer.inlineTokens(text)
-    };
-    lexer.state.inLink = false;
-    return token;
-  }
-  return {
-    type: 'image',
-    raw,
-    href,
-    title,
-    text
-  };
-}
-function indentCodeCompensation(raw, text, rules) {
-  const matchIndentToCode = raw.match(rules.other.indentCodeCompensation);
-  if (matchIndentToCode === null) {
-    return text;
-  }
-  const indentToCode = matchIndentToCode[1];
-  return text.split('\n').map(node => {
-    const matchIndentInNode = node.match(rules.other.beginningSpace);
-    if (matchIndentInNode === null) {
-      return node;
-    }
-    const [indentInNode] = matchIndentInNode;
-    if (indentInNode.length >= indentToCode.length) {
-      return node.slice(indentToCode.length);
-    }
-    return node;
-  }).join('\n');
-}
-/**
- * Tokenizer
- */
-class _Tokenizer {
-  options;
-  rules; // set by the lexer
-  lexer; // set by the lexer
-  constructor(options) {
-    this.options = options || _defaults;
-  }
-  space(src) {
-    const cap = this.rules.block.newline.exec(src);
-    if (cap && cap[0].length > 0) {
-      return {
-        type: 'space',
-        raw: cap[0]
-      };
-    }
-  }
-  code(src) {
-    const cap = this.rules.block.code.exec(src);
-    if (cap) {
-      const text = cap[0].replace(this.rules.other.codeRemoveIndent, '');
-      return {
-        type: 'code',
-        raw: cap[0],
-        codeBlockStyle: 'indented',
-        text: !this.options.pedantic ? rtrim(text, '\n') : text
-      };
-    }
-  }
-  fences(src) {
-    const cap = this.rules.block.fences.exec(src);
-    if (cap) {
-      const raw = cap[0];
-      const text = indentCodeCompensation(raw, cap[3] || '', this.rules);
-      return {
-        type: 'code',
-        raw,
-        lang: cap[2] ? cap[2].trim().replace(this.rules.inline.anyPunctuation, '$1') : cap[2],
-        text
-      };
-    }
-  }
-  heading(src) {
-    const cap = this.rules.block.heading.exec(src);
-    if (cap) {
-      let text = cap[2].trim();
-      // remove trailing #s
-      if (this.rules.other.endingHash.test(text)) {
-        const trimmed = rtrim(text, '#');
-        if (this.options.pedantic) {
-          text = trimmed.trim();
-        } else if (!trimmed || this.rules.other.endingSpaceChar.test(trimmed)) {
-          // CommonMark requires space before trailing #s
-          text = trimmed.trim();
-        }
-      }
-      return {
-        type: 'heading',
-        raw: cap[0],
-        depth: cap[1].length,
-        text,
-        tokens: this.lexer.inline(text)
-      };
-    }
-  }
-  hr(src) {
-    const cap = this.rules.block.hr.exec(src);
-    if (cap) {
-      return {
-        type: 'hr',
-        raw: rtrim(cap[0], '\n')
-      };
-    }
-  }
-  blockquote(src) {
-    const cap = this.rules.block.blockquote.exec(src);
-    if (cap) {
-      let lines = rtrim(cap[0], '\n').split('\n');
-      let raw = '';
-      let text = '';
-      const tokens = [];
-      while (lines.length > 0) {
-        let inBlockquote = false;
-        const currentLines = [];
-        let i;
-        for (i = 0; i < lines.length; i++) {
-          // get lines up to a continuation
-          if (this.rules.other.blockquoteStart.test(lines[i])) {
-            currentLines.push(lines[i]);
-            inBlockquote = true;
-          } else if (!inBlockquote) {
-            currentLines.push(lines[i]);
-          } else {
-            break;
-          }
-        }
-        lines = lines.slice(i);
-        const currentRaw = currentLines.join('\n');
-        const currentText = currentRaw
-        // precede setext continuation with 4 spaces so it isn't a setext
-        .replace(this.rules.other.blockquoteSetextReplace, '\n    $1').replace(this.rules.other.blockquoteSetextReplace2, '');
-        raw = raw ? `${raw}\n${currentRaw}` : currentRaw;
-        text = text ? `${text}\n${currentText}` : currentText;
-        // parse blockquote lines as top level tokens
-        // merge paragraphs if this is a continuation
-        const top = this.lexer.state.top;
-        this.lexer.state.top = true;
-        this.lexer.blockTokens(currentText, tokens, true);
-        this.lexer.state.top = top;
-        // if there is no continuation then we are done
-        if (lines.length === 0) {
-          break;
-        }
-        const lastToken = tokens.at(-1);
-        if (lastToken?.type === 'code') {
-          // blockquote continuation cannot be preceded by a code block
-          break;
-        } else if (lastToken?.type === 'blockquote') {
-          // include continuation in nested blockquote
-          const oldToken = lastToken;
-          const newText = oldToken.raw + '\n' + lines.join('\n');
-          const newToken = this.blockquote(newText);
-          tokens[tokens.length - 1] = newToken;
-          raw = raw.substring(0, raw.length - oldToken.raw.length) + newToken.raw;
-          text = text.substring(0, text.length - oldToken.text.length) + newToken.text;
-          break;
-        } else if (lastToken?.type === 'list') {
-          // include continuation in nested list
-          const oldToken = lastToken;
-          const newText = oldToken.raw + '\n' + lines.join('\n');
-          const newToken = this.list(newText);
-          tokens[tokens.length - 1] = newToken;
-          raw = raw.substring(0, raw.length - lastToken.raw.length) + newToken.raw;
-          text = text.substring(0, text.length - oldToken.raw.length) + newToken.raw;
-          lines = newText.substring(tokens.at(-1).raw.length).split('\n');
-          continue;
-        }
-      }
-      return {
-        type: 'blockquote',
-        raw,
-        tokens,
-        text
-      };
-    }
-  }
-  list(src) {
-    let cap = this.rules.block.list.exec(src);
-    if (cap) {
-      let bull = cap[1].trim();
-      const isordered = bull.length > 1;
-      const list = {
-        type: 'list',
-        raw: '',
-        ordered: isordered,
-        start: isordered ? +bull.slice(0, -1) : '',
-        loose: false,
-        items: []
-      };
-      bull = isordered ? `\\d{1,9}\\${bull.slice(-1)}` : `\\${bull}`;
-      if (this.options.pedantic) {
-        bull = isordered ? bull : '[*+-]';
-      }
-      // Get next list item
-      const itemRegex = this.rules.other.listItemRegex(bull);
-      let endsWithBlankLine = false;
-      // Check if current bullet point can start a new List Item
-      while (src) {
-        let endEarly = false;
-        let raw = '';
-        let itemContents = '';
-        if (!(cap = itemRegex.exec(src))) {
-          break;
-        }
-        if (this.rules.block.hr.test(src)) {
-          // End list if bullet was actually HR (possibly move into itemRegex?)
-          break;
-        }
-        raw = cap[0];
-        src = src.substring(raw.length);
-        let line = cap[2].split('\n', 1)[0].replace(this.rules.other.listReplaceTabs, t => ' '.repeat(3 * t.length));
-        let nextLine = src.split('\n', 1)[0];
-        let blankLine = !line.trim();
-        let indent = 0;
-        if (this.options.pedantic) {
-          indent = 2;
-          itemContents = line.trimStart();
-        } else if (blankLine) {
-          indent = cap[1].length + 1;
-        } else {
-          indent = cap[2].search(this.rules.other.nonSpaceChar); // Find first non-space char
-          indent = indent > 4 ? 1 : indent; // Treat indented code blocks (> 4 spaces) as having only 1 indent
-          itemContents = line.slice(indent);
-          indent += cap[1].length;
-        }
-        if (blankLine && this.rules.other.blankLine.test(nextLine)) {
-          // Items begin with at most one blank line
-          raw += nextLine + '\n';
-          src = src.substring(nextLine.length + 1);
-          endEarly = true;
-        }
-        if (!endEarly) {
-          const nextBulletRegex = this.rules.other.nextBulletRegex(indent);
-          const hrRegex = this.rules.other.hrRegex(indent);
-          const fencesBeginRegex = this.rules.other.fencesBeginRegex(indent);
-          const headingBeginRegex = this.rules.other.headingBeginRegex(indent);
-          const htmlBeginRegex = this.rules.other.htmlBeginRegex(indent);
-          // Check if following lines should be included in List Item
-          while (src) {
-            const rawLine = src.split('\n', 1)[0];
-            let nextLineWithoutTabs;
-            nextLine = rawLine;
-            // Re-align to follow commonmark nesting rules
-            if (this.options.pedantic) {
-              nextLine = nextLine.replace(this.rules.other.listReplaceNesting, '  ');
-              nextLineWithoutTabs = nextLine;
-            } else {
-              nextLineWithoutTabs = nextLine.replace(this.rules.other.tabCharGlobal, '    ');
-            }
-            // End list item if found code fences
-            if (fencesBeginRegex.test(nextLine)) {
-              break;
-            }
-            // End list item if found start of new heading
-            if (headingBeginRegex.test(nextLine)) {
-              break;
-            }
-            // End list item if found start of html block
-            if (htmlBeginRegex.test(nextLine)) {
-              break;
-            }
-            // End list item if found start of new bullet
-            if (nextBulletRegex.test(nextLine)) {
-              break;
-            }
-            // Horizontal rule found
-            if (hrRegex.test(nextLine)) {
-              break;
-            }
-            if (nextLineWithoutTabs.search(this.rules.other.nonSpaceChar) >= indent || !nextLine.trim()) {
-              // Dedent if possible
-              itemContents += '\n' + nextLineWithoutTabs.slice(indent);
-            } else {
-              // not enough indentation
-              if (blankLine) {
-                break;
-              }
-              // paragraph continuation unless last line was a different block level element
-              if (line.replace(this.rules.other.tabCharGlobal, '    ').search(this.rules.other.nonSpaceChar) >= 4) {
-                // indented code block
-                break;
-              }
-              if (fencesBeginRegex.test(line)) {
-                break;
-              }
-              if (headingBeginRegex.test(line)) {
-                break;
-              }
-              if (hrRegex.test(line)) {
-                break;
-              }
-              itemContents += '\n' + nextLine;
-            }
-            if (!blankLine && !nextLine.trim()) {
-              // Check if current line is blank
-              blankLine = true;
-            }
-            raw += rawLine + '\n';
-            src = src.substring(rawLine.length + 1);
-            line = nextLineWithoutTabs.slice(indent);
-          }
-        }
-        if (!list.loose) {
-          // If the previous item ended with a blank line, the list is loose
-          if (endsWithBlankLine) {
-            list.loose = true;
-          } else if (this.rules.other.doubleBlankLine.test(raw)) {
-            endsWithBlankLine = true;
-          }
-        }
-        let istask = null;
-        let ischecked;
-        // Check for task list items
-        if (this.options.gfm) {
-          istask = this.rules.other.listIsTask.exec(itemContents);
-          if (istask) {
-            ischecked = istask[0] !== '[ ] ';
-            itemContents = itemContents.replace(this.rules.other.listReplaceTask, '');
-          }
-        }
-        list.items.push({
-          type: 'list_item',
-          raw,
-          task: !!istask,
-          checked: ischecked,
-          loose: false,
-          text: itemContents,
-          tokens: []
-        });
-        list.raw += raw;
-      }
-      // Do not consume newlines at end of final item. Alternatively, make itemRegex *start* with any newlines to simplify/speed up endsWithBlankLine logic
-      const lastItem = list.items.at(-1);
-      if (lastItem) {
-        lastItem.raw = lastItem.raw.trimEnd();
-        lastItem.text = lastItem.text.trimEnd();
-      } else {
-        // not a list since there were no items
-        return;
-      }
-      list.raw = list.raw.trimEnd();
-      // Item child tokens handled here at end because we needed to have the final item to trim it first
-      for (let i = 0; i < list.items.length; i++) {
-        this.lexer.state.top = false;
-        list.items[i].tokens = this.lexer.blockTokens(list.items[i].text, []);
-        if (!list.loose) {
-          // Check if list should be loose
-          const spacers = list.items[i].tokens.filter(t => t.type === 'space');
-          const hasMultipleLineBreaks = spacers.length > 0 && spacers.some(t => this.rules.other.anyLine.test(t.raw));
-          list.loose = hasMultipleLineBreaks;
-        }
-      }
-      // Set all items to loose if list is loose
-      if (list.loose) {
-        for (let i = 0; i < list.items.length; i++) {
-          list.items[i].loose = true;
-        }
-      }
-      return list;
-    }
-  }
-  html(src) {
-    const cap = this.rules.block.html.exec(src);
-    if (cap) {
-      const token = {
-        type: 'html',
-        block: true,
-        raw: cap[0],
-        pre: cap[1] === 'pre' || cap[1] === 'script' || cap[1] === 'style',
-        text: cap[0]
-      };
-      return token;
-    }
-  }
-  def(src) {
-    const cap = this.rules.block.def.exec(src);
-    if (cap) {
-      const tag = cap[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, ' ');
-      const href = cap[2] ? cap[2].replace(this.rules.other.hrefBrackets, '$1').replace(this.rules.inline.anyPunctuation, '$1') : '';
-      const title = cap[3] ? cap[3].substring(1, cap[3].length - 1).replace(this.rules.inline.anyPunctuation, '$1') : cap[3];
-      return {
-        type: 'def',
-        tag,
-        raw: cap[0],
-        href,
-        title
-      };
-    }
-  }
-  table(src) {
-    const cap = this.rules.block.table.exec(src);
-    if (!cap) {
-      return;
-    }
-    if (!this.rules.other.tableDelimiter.test(cap[2])) {
-      // delimiter row must have a pipe (|) or colon (:) otherwise it is a setext heading
-      return;
-    }
-    const headers = splitCells(cap[1]);
-    const aligns = cap[2].replace(this.rules.other.tableAlignChars, '').split('|');
-    const rows = cap[3]?.trim() ? cap[3].replace(this.rules.other.tableRowBlankLine, '').split('\n') : [];
-    const item = {
-      type: 'table',
-      raw: cap[0],
-      header: [],
-      align: [],
-      rows: []
-    };
-    if (headers.length !== aligns.length) {
-      // header and align columns must be equal, rows can be different.
-      return;
-    }
-    for (const align of aligns) {
-      if (this.rules.other.tableAlignRight.test(align)) {
-        item.align.push('right');
-      } else if (this.rules.other.tableAlignCenter.test(align)) {
-        item.align.push('center');
-      } else if (this.rules.other.tableAlignLeft.test(align)) {
-        item.align.push('left');
-      } else {
-        item.align.push(null);
-      }
-    }
-    for (let i = 0; i < headers.length; i++) {
-      item.header.push({
-        text: headers[i],
-        tokens: this.lexer.inline(headers[i]),
-        header: true,
-        align: item.align[i]
-      });
-    }
-    for (const row of rows) {
-      item.rows.push(splitCells(row, item.header.length).map((cell, i) => {
-        return {
-          text: cell,
-          tokens: this.lexer.inline(cell),
-          header: false,
-          align: item.align[i]
-        };
-      }));
-    }
-    return item;
-  }
-  lheading(src) {
-    const cap = this.rules.block.lheading.exec(src);
-    if (cap) {
-      return {
-        type: 'heading',
-        raw: cap[0],
-        depth: cap[2].charAt(0) === '=' ? 1 : 2,
-        text: cap[1],
-        tokens: this.lexer.inline(cap[1])
-      };
-    }
-  }
-  paragraph(src) {
-    const cap = this.rules.block.paragraph.exec(src);
-    if (cap) {
-      const text = cap[1].charAt(cap[1].length - 1) === '\n' ? cap[1].slice(0, -1) : cap[1];
-      return {
-        type: 'paragraph',
-        raw: cap[0],
-        text,
-        tokens: this.lexer.inline(text)
-      };
-    }
-  }
-  text(src) {
-    const cap = this.rules.block.text.exec(src);
-    if (cap) {
-      return {
-        type: 'text',
-        raw: cap[0],
-        text: cap[0],
-        tokens: this.lexer.inline(cap[0])
-      };
-    }
-  }
-  escape(src) {
-    const cap = this.rules.inline.escape.exec(src);
-    if (cap) {
-      return {
-        type: 'escape',
-        raw: cap[0],
-        text: cap[1]
-      };
-    }
-  }
-  tag(src) {
-    const cap = this.rules.inline.tag.exec(src);
-    if (cap) {
-      if (!this.lexer.state.inLink && this.rules.other.startATag.test(cap[0])) {
-        this.lexer.state.inLink = true;
-      } else if (this.lexer.state.inLink && this.rules.other.endATag.test(cap[0])) {
-        this.lexer.state.inLink = false;
-      }
-      if (!this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(cap[0])) {
-        this.lexer.state.inRawBlock = true;
-      } else if (this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(cap[0])) {
-        this.lexer.state.inRawBlock = false;
-      }
-      return {
-        type: 'html',
-        raw: cap[0],
-        inLink: this.lexer.state.inLink,
-        inRawBlock: this.lexer.state.inRawBlock,
-        block: false,
-        text: cap[0]
-      };
-    }
-  }
-  link(src) {
-    const cap = this.rules.inline.link.exec(src);
-    if (cap) {
-      const trimmedUrl = cap[2].trim();
-      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(trimmedUrl)) {
-        // commonmark requires matching angle brackets
-        if (!this.rules.other.endAngleBracket.test(trimmedUrl)) {
-          return;
-        }
-        // ending angle bracket cannot be escaped
-        const rtrimSlash = rtrim(trimmedUrl.slice(0, -1), '\\');
-        if ((trimmedUrl.length - rtrimSlash.length) % 2 === 0) {
-          return;
-        }
-      } else {
-        // find closing parenthesis
-        const lastParenIndex = findClosingBracket(cap[2], '()');
-        if (lastParenIndex === -2) {
-          // more open parens than closed
-          return;
-        }
-        if (lastParenIndex > -1) {
-          const start = cap[0].indexOf('!') === 0 ? 5 : 4;
-          const linkLen = start + cap[1].length + lastParenIndex;
-          cap[2] = cap[2].substring(0, lastParenIndex);
-          cap[0] = cap[0].substring(0, linkLen).trim();
-          cap[3] = '';
-        }
-      }
-      let href = cap[2];
-      let title = '';
-      if (this.options.pedantic) {
-        // split pedantic href and title
-        const link = this.rules.other.pedanticHrefTitle.exec(href);
-        if (link) {
-          href = link[1];
-          title = link[3];
-        }
-      } else {
-        title = cap[3] ? cap[3].slice(1, -1) : '';
-      }
-      href = href.trim();
-      if (this.rules.other.startAngleBracket.test(href)) {
-        if (this.options.pedantic && !this.rules.other.endAngleBracket.test(trimmedUrl)) {
-          // pedantic allows starting angle bracket without ending angle bracket
-          href = href.slice(1);
-        } else {
-          href = href.slice(1, -1);
-        }
-      }
-      return outputLink(cap, {
-        href: href ? href.replace(this.rules.inline.anyPunctuation, '$1') : href,
-        title: title ? title.replace(this.rules.inline.anyPunctuation, '$1') : title
-      }, cap[0], this.lexer, this.rules);
-    }
-  }
-  reflink(src, links) {
-    let cap;
-    if ((cap = this.rules.inline.reflink.exec(src)) || (cap = this.rules.inline.nolink.exec(src))) {
-      const linkString = (cap[2] || cap[1]).replace(this.rules.other.multipleSpaceGlobal, ' ');
-      const link = links[linkString.toLowerCase()];
-      if (!link) {
-        const text = cap[0].charAt(0);
-        return {
-          type: 'text',
-          raw: text,
-          text
-        };
-      }
-      return outputLink(cap, link, cap[0], this.lexer, this.rules);
-    }
-  }
-  emStrong(src, maskedSrc, prevChar = '') {
-    let match = this.rules.inline.emStrongLDelim.exec(src);
-    if (!match) return;
-    // _ can't be between two alphanumerics. \p{L}\p{N} includes non-english alphabet/numbers as well
-    if (match[3] && prevChar.match(this.rules.other.unicodeAlphaNumeric)) return;
-    const nextChar = match[1] || match[2] || '';
-    if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
-      // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)
-      const lLength = [...match[0]].length - 1;
-      let rDelim,
-        rLength,
-        delimTotal = lLength,
-        midDelimTotal = 0;
-      const endReg = match[0][0] === '*' ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
-      endReg.lastIndex = 0;
-      // Clip maskedSrc to same section of string as src (move to lexer?)
-      maskedSrc = maskedSrc.slice(-1 * src.length + lLength);
-      while ((match = endReg.exec(maskedSrc)) != null) {
-        rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
-        if (!rDelim) continue; // skip single * in __abc*abc__
-        rLength = [...rDelim].length;
-        if (match[3] || match[4]) {
-          // found another Left Delim
-          delimTotal += rLength;
-          continue;
-        } else if (match[5] || match[6]) {
-          // either Left or Right Delim
-          if (lLength % 3 && !((lLength + rLength) % 3)) {
-            midDelimTotal += rLength;
-            continue; // CommonMark Emphasis Rules 9-10
-          }
-        }
-        delimTotal -= rLength;
-        if (delimTotal > 0) continue; // Haven't found enough closing delimiters
-        // Remove extra characters. *a*** -> *a*
-        rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
-        // char length can be >1 for unicode characters;
-        const lastCharLength = [...match[0]][0].length;
-        const raw = src.slice(0, lLength + match.index + lastCharLength + rLength);
-        // Create `em` if smallest delimiter has odd char count. *a***
-        if (Math.min(lLength, rLength) % 2) {
-          const text = raw.slice(1, -1);
-          return {
-            type: 'em',
-            raw,
-            text,
-            tokens: this.lexer.inlineTokens(text)
-          };
-        }
-        // Create 'strong' if smallest delimiter has even char count. **a***
-        const text = raw.slice(2, -2);
-        return {
-          type: 'strong',
-          raw,
-          text,
-          tokens: this.lexer.inlineTokens(text)
-        };
-      }
-    }
-  }
-  codespan(src) {
-    const cap = this.rules.inline.code.exec(src);
-    if (cap) {
-      let text = cap[2].replace(this.rules.other.newLineCharGlobal, ' ');
-      const hasNonSpaceChars = this.rules.other.nonSpaceChar.test(text);
-      const hasSpaceCharsOnBothEnds = this.rules.other.startingSpaceChar.test(text) && this.rules.other.endingSpaceChar.test(text);
-      if (hasNonSpaceChars && hasSpaceCharsOnBothEnds) {
-        text = text.substring(1, text.length - 1);
-      }
-      return {
-        type: 'codespan',
-        raw: cap[0],
-        text
-      };
-    }
-  }
-  br(src) {
-    const cap = this.rules.inline.br.exec(src);
-    if (cap) {
-      return {
-        type: 'br',
-        raw: cap[0]
-      };
-    }
-  }
-  del(src) {
-    const cap = this.rules.inline.del.exec(src);
-    if (cap) {
-      return {
-        type: 'del',
-        raw: cap[0],
-        text: cap[2],
-        tokens: this.lexer.inlineTokens(cap[2])
-      };
-    }
-  }
-  autolink(src) {
-    const cap = this.rules.inline.autolink.exec(src);
-    if (cap) {
-      let text, href;
-      if (cap[2] === '@') {
-        text = cap[1];
-        href = 'mailto:' + text;
-      } else {
-        text = cap[1];
-        href = text;
-      }
-      return {
-        type: 'link',
-        raw: cap[0],
-        text,
-        href,
-        tokens: [{
-          type: 'text',
-          raw: text,
-          text
-        }]
-      };
-    }
-  }
-  url(src) {
-    let cap;
-    if (cap = this.rules.inline.url.exec(src)) {
-      let text, href;
-      if (cap[2] === '@') {
-        text = cap[0];
-        href = 'mailto:' + text;
-      } else {
-        // do extended autolink path validation
-        let prevCapZero;
-        do {
-          prevCapZero = cap[0];
-          cap[0] = this.rules.inline._backpedal.exec(cap[0])?.[0] ?? '';
-        } while (prevCapZero !== cap[0]);
-        text = cap[0];
-        if (cap[1] === 'www.') {
-          href = 'http://' + cap[0];
-        } else {
-          href = cap[0];
-        }
-      }
-      return {
-        type: 'link',
-        raw: cap[0],
-        text,
-        href,
-        tokens: [{
-          type: 'text',
-          raw: text,
-          text
-        }]
-      };
-    }
-  }
-  inlineText(src) {
-    const cap = this.rules.inline.text.exec(src);
-    if (cap) {
-      const escaped = this.lexer.state.inRawBlock;
-      return {
-        type: 'text',
-        raw: cap[0],
-        text: cap[0],
-        escaped
-      };
-    }
-  }
-}
-
-/**
- * Block Lexer
- */
-class _Lexer {
-  tokens;
-  options;
-  state;
-  tokenizer;
-  inlineQueue;
-  constructor(options) {
-    // TokenList cannot be created in one go
-    this.tokens = [];
-    this.tokens.links = Object.create(null);
-    this.options = options || _defaults;
-    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
-    this.tokenizer = this.options.tokenizer;
-    this.tokenizer.options = this.options;
-    this.tokenizer.lexer = this;
-    this.inlineQueue = [];
-    this.state = {
-      inLink: false,
-      inRawBlock: false,
-      top: true
-    };
-    const rules = {
-      other,
-      block: block.normal,
-      inline: inline.normal
-    };
-    if (this.options.pedantic) {
-      rules.block = block.pedantic;
-      rules.inline = inline.pedantic;
-    } else if (this.options.gfm) {
-      rules.block = block.gfm;
-      if (this.options.breaks) {
-        rules.inline = inline.breaks;
-      } else {
-        rules.inline = inline.gfm;
-      }
-    }
-    this.tokenizer.rules = rules;
-  }
-  /**
-   * Expose Rules
-   */
-  static get rules() {
-    return {
-      block,
-      inline
-    };
-  }
-  /**
-   * Static Lex Method
-   */
-  static lex(src, options) {
-    const lexer = new _Lexer(options);
-    return lexer.lex(src);
-  }
-  /**
-   * Static Lex Inline Method
-   */
-  static lexInline(src, options) {
-    const lexer = new _Lexer(options);
-    return lexer.inlineTokens(src);
-  }
-  /**
-   * Preprocessing
-   */
-  lex(src) {
-    src = src.replace(other.carriageReturn, '\n');
-    this.blockTokens(src, this.tokens);
-    for (let i = 0; i < this.inlineQueue.length; i++) {
-      const next = this.inlineQueue[i];
-      this.inlineTokens(next.src, next.tokens);
-    }
-    this.inlineQueue = [];
-    return this.tokens;
-  }
-  blockTokens(src, tokens = [], lastParagraphClipped = false) {
-    if (this.options.pedantic) {
-      src = src.replace(other.tabCharGlobal, '    ').replace(other.spaceLine, '');
-    }
-    while (src) {
-      let token;
-      if (this.options.extensions?.block?.some(extTokenizer => {
-        if (token = extTokenizer.call({
-          lexer: this
-        }, src, tokens)) {
-          src = src.substring(token.raw.length);
-          tokens.push(token);
-          return true;
-        }
-        return false;
-      })) {
-        continue;
-      }
-      // newline
-      if (token = this.tokenizer.space(src)) {
-        src = src.substring(token.raw.length);
-        const lastToken = tokens.at(-1);
-        if (token.raw.length === 1 && lastToken !== undefined) {
-          // if there's a single \n as a spacer, it's terminating the last line,
-          // so move it there so that we don't get unnecessary paragraph tags
-          lastToken.raw += '\n';
-        } else {
-          tokens.push(token);
-        }
-        continue;
-      }
-      // code
-      if (token = this.tokenizer.code(src)) {
-        src = src.substring(token.raw.length);
-        const lastToken = tokens.at(-1);
-        // An indented code block cannot interrupt a paragraph.
-        if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {
-          lastToken.raw += '\n' + token.raw;
-          lastToken.text += '\n' + token.text;
-          this.inlineQueue.at(-1).src = lastToken.text;
-        } else {
-          tokens.push(token);
-        }
-        continue;
-      }
-      // fences
-      if (token = this.tokenizer.fences(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // heading
-      if (token = this.tokenizer.heading(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // hr
-      if (token = this.tokenizer.hr(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // blockquote
-      if (token = this.tokenizer.blockquote(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // list
-      if (token = this.tokenizer.list(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // html
-      if (token = this.tokenizer.html(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // def
-      if (token = this.tokenizer.def(src)) {
-        src = src.substring(token.raw.length);
-        const lastToken = tokens.at(-1);
-        if (lastToken?.type === 'paragraph' || lastToken?.type === 'text') {
-          lastToken.raw += '\n' + token.raw;
-          lastToken.text += '\n' + token.raw;
-          this.inlineQueue.at(-1).src = lastToken.text;
-        } else if (!this.tokens.links[token.tag]) {
-          this.tokens.links[token.tag] = {
-            href: token.href,
-            title: token.title
-          };
-        }
-        continue;
-      }
-      // table (gfm)
-      if (token = this.tokenizer.table(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // lheading
-      if (token = this.tokenizer.lheading(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // top-level paragraph
-      // prevent paragraph consuming extensions by clipping 'src' to extension start
-      let cutSrc = src;
-      if (this.options.extensions?.startBlock) {
-        let startIndex = Infinity;
-        const tempSrc = src.slice(1);
-        let tempStart;
-        this.options.extensions.startBlock.forEach(getStartIndex => {
-          tempStart = getStartIndex.call({
-            lexer: this
-          }, tempSrc);
-          if (typeof tempStart === 'number' && tempStart >= 0) {
-            startIndex = Math.min(startIndex, tempStart);
-          }
-        });
-        if (startIndex < Infinity && startIndex >= 0) {
-          cutSrc = src.substring(0, startIndex + 1);
-        }
-      }
-      if (this.state.top && (token = this.tokenizer.paragraph(cutSrc))) {
-        const lastToken = tokens.at(-1);
-        if (lastParagraphClipped && lastToken?.type === 'paragraph') {
-          lastToken.raw += '\n' + token.raw;
-          lastToken.text += '\n' + token.text;
-          this.inlineQueue.pop();
-          this.inlineQueue.at(-1).src = lastToken.text;
-        } else {
-          tokens.push(token);
-        }
-        lastParagraphClipped = cutSrc.length !== src.length;
-        src = src.substring(token.raw.length);
-        continue;
-      }
-      // text
-      if (token = this.tokenizer.text(src)) {
-        src = src.substring(token.raw.length);
-        const lastToken = tokens.at(-1);
-        if (lastToken?.type === 'text') {
-          lastToken.raw += '\n' + token.raw;
-          lastToken.text += '\n' + token.text;
-          this.inlineQueue.pop();
-          this.inlineQueue.at(-1).src = lastToken.text;
-        } else {
-          tokens.push(token);
-        }
-        continue;
-      }
-      if (src) {
-        const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
-        if (this.options.silent) {
-          console.error(errMsg);
-          break;
-        } else {
-          throw new Error(errMsg);
-        }
-      }
-    }
-    this.state.top = true;
-    return tokens;
-  }
-  inline(src, tokens = []) {
-    this.inlineQueue.push({
-      src,
-      tokens
-    });
-    return tokens;
-  }
-  /**
-   * Lexing/Compiling
-   */
-  inlineTokens(src, tokens = []) {
-    // String with links masked to avoid interference with em and strong
-    let maskedSrc = src;
-    let match = null;
-    // Mask out reflinks
-    if (this.tokens.links) {
-      const links = Object.keys(this.tokens.links);
-      if (links.length > 0) {
-        while ((match = this.tokenizer.rules.inline.reflinkSearch.exec(maskedSrc)) != null) {
-          if (links.includes(match[0].slice(match[0].lastIndexOf('[') + 1, -1))) {
-            maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex);
-          }
-        }
-      }
-    }
-    // Mask out escaped characters
-    while ((match = this.tokenizer.rules.inline.anyPunctuation.exec(maskedSrc)) != null) {
-      maskedSrc = maskedSrc.slice(0, match.index) + '++' + maskedSrc.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);
-    }
-    // Mask out other blocks
-    while ((match = this.tokenizer.rules.inline.blockSkip.exec(maskedSrc)) != null) {
-      maskedSrc = maskedSrc.slice(0, match.index) + '[' + 'a'.repeat(match[0].length - 2) + ']' + maskedSrc.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);
-    }
-    let keepPrevChar = false;
-    let prevChar = '';
-    while (src) {
-      if (!keepPrevChar) {
-        prevChar = '';
-      }
-      keepPrevChar = false;
-      let token;
-      // extensions
-      if (this.options.extensions?.inline?.some(extTokenizer => {
-        if (token = extTokenizer.call({
-          lexer: this
-        }, src, tokens)) {
-          src = src.substring(token.raw.length);
-          tokens.push(token);
-          return true;
-        }
-        return false;
-      })) {
-        continue;
-      }
-      // escape
-      if (token = this.tokenizer.escape(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // tag
-      if (token = this.tokenizer.tag(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // link
-      if (token = this.tokenizer.link(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // reflink, nolink
-      if (token = this.tokenizer.reflink(src, this.tokens.links)) {
-        src = src.substring(token.raw.length);
-        const lastToken = tokens.at(-1);
-        if (token.type === 'text' && lastToken?.type === 'text') {
-          lastToken.raw += token.raw;
-          lastToken.text += token.text;
-        } else {
-          tokens.push(token);
-        }
-        continue;
-      }
-      // em & strong
-      if (token = this.tokenizer.emStrong(src, maskedSrc, prevChar)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // code
-      if (token = this.tokenizer.codespan(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // br
-      if (token = this.tokenizer.br(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // del (gfm)
-      if (token = this.tokenizer.del(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // autolink
-      if (token = this.tokenizer.autolink(src)) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // url (gfm)
-      if (!this.state.inLink && (token = this.tokenizer.url(src))) {
-        src = src.substring(token.raw.length);
-        tokens.push(token);
-        continue;
-      }
-      // text
-      // prevent inlineText consuming extensions by clipping 'src' to extension start
-      let cutSrc = src;
-      if (this.options.extensions?.startInline) {
-        let startIndex = Infinity;
-        const tempSrc = src.slice(1);
-        let tempStart;
-        this.options.extensions.startInline.forEach(getStartIndex => {
-          tempStart = getStartIndex.call({
-            lexer: this
-          }, tempSrc);
-          if (typeof tempStart === 'number' && tempStart >= 0) {
-            startIndex = Math.min(startIndex, tempStart);
-          }
-        });
-        if (startIndex < Infinity && startIndex >= 0) {
-          cutSrc = src.substring(0, startIndex + 1);
-        }
-      }
-      if (token = this.tokenizer.inlineText(cutSrc)) {
-        src = src.substring(token.raw.length);
-        if (token.raw.slice(-1) !== '_') {
-          // Track prevChar before string of ____ started
-          prevChar = token.raw.slice(-1);
-        }
-        keepPrevChar = true;
-        const lastToken = tokens.at(-1);
-        if (lastToken?.type === 'text') {
-          lastToken.raw += token.raw;
-          lastToken.text += token.text;
-        } else {
-          tokens.push(token);
-        }
-        continue;
-      }
-      if (src) {
-        const errMsg = 'Infinite loop on byte: ' + src.charCodeAt(0);
-        if (this.options.silent) {
-          console.error(errMsg);
-          break;
-        } else {
-          throw new Error(errMsg);
-        }
-      }
-    }
-    return tokens;
-  }
-}
-
-/**
- * Renderer
- */
-class _Renderer {
-  options;
-  parser; // set by the parser
-  constructor(options) {
-    this.options = options || _defaults;
-  }
-  space(token) {
-    return '';
-  }
-  code({
-    text,
-    lang,
-    escaped
-  }) {
-    const langString = (lang || '').match(other.notSpaceStart)?.[0];
-    const code = text.replace(other.endingNewline, '') + '\n';
-    if (!langString) {
-      return '<pre><code>' + (escaped ? code : escape(code, true)) + '</code></pre>\n';
-    }
-    return '<pre><code class="language-' + escape(langString) + '">' + (escaped ? code : escape(code, true)) + '</code></pre>\n';
-  }
-  blockquote({
-    tokens
-  }) {
-    const body = this.parser.parse(tokens);
-    return `<blockquote>\n${body}</blockquote>\n`;
-  }
-  html({
-    text
-  }) {
-    return text;
-  }
-  heading({
-    tokens,
-    depth
-  }) {
-    return `<h${depth}>${this.parser.parseInline(tokens)}</h${depth}>\n`;
-  }
-  hr(token) {
-    return '<hr>\n';
-  }
-  list(token) {
-    const ordered = token.ordered;
-    const start = token.start;
-    let body = '';
-    for (let j = 0; j < token.items.length; j++) {
-      const item = token.items[j];
-      body += this.listitem(item);
-    }
-    const type = ordered ? 'ol' : 'ul';
-    const startAttr = ordered && start !== 1 ? ' start="' + start + '"' : '';
-    return '<' + type + startAttr + '>\n' + body + '</' + type + '>\n';
-  }
-  listitem(item) {
-    let itemBody = '';
-    if (item.task) {
-      const checkbox = this.checkbox({
-        checked: !!item.checked
-      });
-      if (item.loose) {
-        if (item.tokens[0]?.type === 'paragraph') {
-          item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
-          if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
-            item.tokens[0].tokens[0].text = checkbox + ' ' + escape(item.tokens[0].tokens[0].text);
-            item.tokens[0].tokens[0].escaped = true;
-          }
-        } else {
-          item.tokens.unshift({
-            type: 'text',
-            raw: checkbox + ' ',
-            text: checkbox + ' ',
-            escaped: true
-          });
-        }
-      } else {
-        itemBody += checkbox + ' ';
-      }
-    }
-    itemBody += this.parser.parse(item.tokens, !!item.loose);
-    return `<li>${itemBody}</li>\n`;
-  }
-  checkbox({
-    checked
-  }) {
-    return '<input ' + (checked ? 'checked="" ' : '') + 'disabled="" type="checkbox">';
-  }
-  paragraph({
-    tokens
-  }) {
-    return `<p>${this.parser.parseInline(tokens)}</p>\n`;
-  }
-  table(token) {
-    let header = '';
-    // header
-    let cell = '';
-    for (let j = 0; j < token.header.length; j++) {
-      cell += this.tablecell(token.header[j]);
-    }
-    header += this.tablerow({
-      text: cell
-    });
-    let body = '';
-    for (let j = 0; j < token.rows.length; j++) {
-      const row = token.rows[j];
-      cell = '';
-      for (let k = 0; k < row.length; k++) {
-        cell += this.tablecell(row[k]);
-      }
-      body += this.tablerow({
-        text: cell
-      });
-    }
-    if (body) body = `<tbody>${body}</tbody>`;
-    return '<table>\n' + '<thead>\n' + header + '</thead>\n' + body + '</table>\n';
-  }
-  tablerow({
-    text
-  }) {
-    return `<tr>\n${text}</tr>\n`;
-  }
-  tablecell(token) {
-    const content = this.parser.parseInline(token.tokens);
-    const type = token.header ? 'th' : 'td';
-    const tag = token.align ? `<${type} align="${token.align}">` : `<${type}>`;
-    return tag + content + `</${type}>\n`;
-  }
-  /**
-   * span level renderer
-   */
-  strong({
-    tokens
-  }) {
-    return `<strong>${this.parser.parseInline(tokens)}</strong>`;
-  }
-  em({
-    tokens
-  }) {
-    return `<em>${this.parser.parseInline(tokens)}</em>`;
-  }
-  codespan({
-    text
-  }) {
-    return `<code>${escape(text, true)}</code>`;
-  }
-  br(token) {
-    return '<br>';
-  }
-  del({
-    tokens
-  }) {
-    return `<del>${this.parser.parseInline(tokens)}</del>`;
-  }
-  link({
-    href,
-    title,
-    tokens
-  }) {
-    const text = this.parser.parseInline(tokens);
-    const cleanHref = cleanUrl(href);
-    if (cleanHref === null) {
-      return text;
-    }
-    href = cleanHref;
-    let out = '<a href="' + href + '"';
-    if (title) {
-      out += ' title="' + escape(title) + '"';
-    }
-    out += '>' + text + '</a>';
-    return out;
-  }
-  image({
-    href,
-    title,
-    text
-  }) {
-    const cleanHref = cleanUrl(href);
-    if (cleanHref === null) {
-      return escape(text);
-    }
-    href = cleanHref;
-    let out = `<img src="${href}" alt="${text}"`;
-    if (title) {
-      out += ` title="${escape(title)}"`;
-    }
-    out += '>';
-    return out;
-  }
-  text(token) {
-    return 'tokens' in token && token.tokens ? this.parser.parseInline(token.tokens) : 'escaped' in token && token.escaped ? token.text : escape(token.text);
-  }
-}
-
-/**
- * TextRenderer
- * returns only the textual part of the token
- */
-class _TextRenderer {
-  // no need for block level renderers
-  strong({
-    text
-  }) {
-    return text;
-  }
-  em({
-    text
-  }) {
-    return text;
-  }
-  codespan({
-    text
-  }) {
-    return text;
-  }
-  del({
-    text
-  }) {
-    return text;
-  }
-  html({
-    text
-  }) {
-    return text;
-  }
-  text({
-    text
-  }) {
-    return text;
-  }
-  link({
-    text
-  }) {
-    return '' + text;
-  }
-  image({
-    text
-  }) {
-    return '' + text;
-  }
-  br() {
-    return '';
-  }
-}
-
-/**
- * Parsing & Compiling
- */
-class _Parser {
-  options;
-  renderer;
-  textRenderer;
-  constructor(options) {
-    this.options = options || _defaults;
-    this.options.renderer = this.options.renderer || new _Renderer();
-    this.renderer = this.options.renderer;
-    this.renderer.options = this.options;
-    this.renderer.parser = this;
-    this.textRenderer = new _TextRenderer();
-  }
-  /**
-   * Static Parse Method
-   */
-  static parse(tokens, options) {
-    const parser = new _Parser(options);
-    return parser.parse(tokens);
-  }
-  /**
-   * Static Parse Inline Method
-   */
-  static parseInline(tokens, options) {
-    const parser = new _Parser(options);
-    return parser.parseInline(tokens);
-  }
-  /**
-   * Parse Loop
-   */
-  parse(tokens, top = true) {
-    let out = '';
-    for (let i = 0; i < tokens.length; i++) {
-      const anyToken = tokens[i];
-      // Run any renderer extensions
-      if (this.options.extensions?.renderers?.[anyToken.type]) {
-        const genericToken = anyToken;
-        const ret = this.options.extensions.renderers[genericToken.type].call({
-          parser: this
-        }, genericToken);
-        if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(genericToken.type)) {
-          out += ret || '';
-          continue;
-        }
-      }
-      const token = anyToken;
-      switch (token.type) {
-        case 'space':
-          {
-            out += this.renderer.space(token);
-            continue;
-          }
-        case 'hr':
-          {
-            out += this.renderer.hr(token);
-            continue;
-          }
-        case 'heading':
-          {
-            out += this.renderer.heading(token);
-            continue;
-          }
-        case 'code':
-          {
-            out += this.renderer.code(token);
-            continue;
-          }
-        case 'table':
-          {
-            out += this.renderer.table(token);
-            continue;
-          }
-        case 'blockquote':
-          {
-            out += this.renderer.blockquote(token);
-            continue;
-          }
-        case 'list':
-          {
-            out += this.renderer.list(token);
-            continue;
-          }
-        case 'html':
-          {
-            out += this.renderer.html(token);
-            continue;
-          }
-        case 'paragraph':
-          {
-            out += this.renderer.paragraph(token);
-            continue;
-          }
-        case 'text':
-          {
-            let textToken = token;
-            let body = this.renderer.text(textToken);
-            while (i + 1 < tokens.length && tokens[i + 1].type === 'text') {
-              textToken = tokens[++i];
-              body += '\n' + this.renderer.text(textToken);
-            }
-            if (top) {
-              out += this.renderer.paragraph({
-                type: 'paragraph',
-                raw: body,
-                text: body,
-                tokens: [{
-                  type: 'text',
-                  raw: body,
-                  text: body,
-                  escaped: true
-                }]
-              });
-            } else {
-              out += body;
-            }
-            continue;
-          }
-        default:
-          {
-            const errMsg = 'Token with "' + token.type + '" type was not found.';
-            if (this.options.silent) {
-              console.error(errMsg);
-              return '';
-            } else {
-              throw new Error(errMsg);
-            }
-          }
-      }
-    }
-    return out;
-  }
-  /**
-   * Parse Inline Tokens
-   */
-  parseInline(tokens, renderer = this.renderer) {
-    let out = '';
-    for (let i = 0; i < tokens.length; i++) {
-      const anyToken = tokens[i];
-      // Run any renderer extensions
-      if (this.options.extensions?.renderers?.[anyToken.type]) {
-        const ret = this.options.extensions.renderers[anyToken.type].call({
-          parser: this
-        }, anyToken);
-        if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(anyToken.type)) {
-          out += ret || '';
-          continue;
-        }
-      }
-      const token = anyToken;
-      switch (token.type) {
-        case 'escape':
-          {
-            out += renderer.text(token);
-            break;
-          }
-        case 'html':
-          {
-            out += renderer.html(token);
-            break;
-          }
-        case 'link':
-          {
-            out += renderer.link(token);
-            break;
-          }
-        case 'image':
-          {
-            out += renderer.image(token);
-            break;
-          }
-        case 'strong':
-          {
-            out += renderer.strong(token);
-            break;
-          }
-        case 'em':
-          {
-            out += renderer.em(token);
-            break;
-          }
-        case 'codespan':
-          {
-            out += renderer.codespan(token);
-            break;
-          }
-        case 'br':
-          {
-            out += renderer.br(token);
-            break;
-          }
-        case 'del':
-          {
-            out += renderer.del(token);
-            break;
-          }
-        case 'text':
-          {
-            out += renderer.text(token);
-            break;
-          }
-        default:
-          {
-            const errMsg = 'Token with "' + token.type + '" type was not found.';
-            if (this.options.silent) {
-              console.error(errMsg);
-              return '';
-            } else {
-              throw new Error(errMsg);
-            }
-          }
-      }
-    }
-    return out;
-  }
-}
-class _Hooks {
-  options;
-  block;
-  constructor(options) {
-    this.options = options || _defaults;
-  }
-  static passThroughHooks = new Set(['preprocess', 'postprocess', 'processAllTokens']);
-  /**
-   * Process markdown before marked
-   */
-  preprocess(markdown) {
-    return markdown;
-  }
-  /**
-   * Process HTML after marked is finished
-   */
-  postprocess(html) {
-    return html;
-  }
-  /**
-   * Process all tokens before walk tokens
-   */
-  processAllTokens(tokens) {
-    return tokens;
-  }
-  /**
-   * Provide function to tokenize markdown
-   */
-  provideLexer() {
-    return this.block ? _Lexer.lex : _Lexer.lexInline;
-  }
-  /**
-   * Provide function to parse tokens
-   */
-  provideParser() {
-    return this.block ? _Parser.parse : _Parser.parseInline;
-  }
-}
-class Marked {
-  defaults = _getDefaults();
-  options = this.setOptions;
-  parse = this.parseMarkdown(true);
-  parseInline = this.parseMarkdown(false);
-  Parser = _Parser;
-  Renderer = _Renderer;
-  TextRenderer = _TextRenderer;
-  Lexer = _Lexer;
-  Tokenizer = _Tokenizer;
-  Hooks = _Hooks;
-  constructor(...args) {
-    this.use(...args);
-  }
-  /**
-   * Run callback for every token
-   */
-  walkTokens(tokens, callback) {
-    let values = [];
-    for (const token of tokens) {
-      values = values.concat(callback.call(this, token));
-      switch (token.type) {
-        case 'table':
-          {
-            const tableToken = token;
-            for (const cell of tableToken.header) {
-              values = values.concat(this.walkTokens(cell.tokens, callback));
-            }
-            for (const row of tableToken.rows) {
-              for (const cell of row) {
-                values = values.concat(this.walkTokens(cell.tokens, callback));
-              }
-            }
-            break;
-          }
-        case 'list':
-          {
-            const listToken = token;
-            values = values.concat(this.walkTokens(listToken.items, callback));
-            break;
-          }
-        default:
-          {
-            const genericToken = token;
-            if (this.defaults.extensions?.childTokens?.[genericToken.type]) {
-              this.defaults.extensions.childTokens[genericToken.type].forEach(childTokens => {
-                const tokens = genericToken[childTokens].flat(Infinity);
-                values = values.concat(this.walkTokens(tokens, callback));
-              });
-            } else if (genericToken.tokens) {
-              values = values.concat(this.walkTokens(genericToken.tokens, callback));
-            }
-          }
-      }
-    }
-    return values;
-  }
-  use(...args) {
-    const extensions = this.defaults.extensions || {
-      renderers: {},
-      childTokens: {}
-    };
-    args.forEach(pack => {
-      // copy options to new object
-      const opts = {
-        ...pack
-      };
-      // set async to true if it was set to true before
-      opts.async = this.defaults.async || opts.async || false;
-      // ==-- Parse "addon" extensions --== //
-      if (pack.extensions) {
-        pack.extensions.forEach(ext => {
-          if (!ext.name) {
-            throw new Error('extension name required');
-          }
-          if ('renderer' in ext) {
-            // Renderer extensions
-            const prevRenderer = extensions.renderers[ext.name];
-            if (prevRenderer) {
-              // Replace extension with func to run new extension but fall back if false
-              extensions.renderers[ext.name] = function (...args) {
-                let ret = ext.renderer.apply(this, args);
-                if (ret === false) {
-                  ret = prevRenderer.apply(this, args);
-                }
-                return ret;
-              };
-            } else {
-              extensions.renderers[ext.name] = ext.renderer;
-            }
-          }
-          if ('tokenizer' in ext) {
-            // Tokenizer Extensions
-            if (!ext.level || ext.level !== 'block' && ext.level !== 'inline') {
-              throw new Error("extension level must be 'block' or 'inline'");
-            }
-            const extLevel = extensions[ext.level];
-            if (extLevel) {
-              extLevel.unshift(ext.tokenizer);
-            } else {
-              extensions[ext.level] = [ext.tokenizer];
-            }
-            if (ext.start) {
-              // Function to check for start of token
-              if (ext.level === 'block') {
-                if (extensions.startBlock) {
-                  extensions.startBlock.push(ext.start);
-                } else {
-                  extensions.startBlock = [ext.start];
-                }
-              } else if (ext.level === 'inline') {
-                if (extensions.startInline) {
-                  extensions.startInline.push(ext.start);
-                } else {
-                  extensions.startInline = [ext.start];
-                }
-              }
-            }
-          }
-          if ('childTokens' in ext && ext.childTokens) {
-            // Child tokens to be visited by walkTokens
-            extensions.childTokens[ext.name] = ext.childTokens;
-          }
-        });
-        opts.extensions = extensions;
-      }
-      // ==-- Parse "overwrite" extensions --== //
-      if (pack.renderer) {
-        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
-        for (const prop in pack.renderer) {
-          if (!(prop in renderer)) {
-            throw new Error(`renderer '${prop}' does not exist`);
-          }
-          if (['options', 'parser'].includes(prop)) {
-            // ignore options property
-            continue;
-          }
-          const rendererProp = prop;
-          const rendererFunc = pack.renderer[rendererProp];
-          const prevRenderer = renderer[rendererProp];
-          // Replace renderer with func to run extension, but fall back if false
-          renderer[rendererProp] = (...args) => {
-            let ret = rendererFunc.apply(renderer, args);
-            if (ret === false) {
-              ret = prevRenderer.apply(renderer, args);
-            }
-            return ret || '';
-          };
-        }
-        opts.renderer = renderer;
-      }
-      if (pack.tokenizer) {
-        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
-        for (const prop in pack.tokenizer) {
-          if (!(prop in tokenizer)) {
-            throw new Error(`tokenizer '${prop}' does not exist`);
-          }
-          if (['options', 'rules', 'lexer'].includes(prop)) {
-            // ignore options, rules, and lexer properties
-            continue;
-          }
-          const tokenizerProp = prop;
-          const tokenizerFunc = pack.tokenizer[tokenizerProp];
-          const prevTokenizer = tokenizer[tokenizerProp];
-          // Replace tokenizer with func to run extension, but fall back if false
-          // @ts-expect-error cannot type tokenizer function dynamically
-          tokenizer[tokenizerProp] = (...args) => {
-            let ret = tokenizerFunc.apply(tokenizer, args);
-            if (ret === false) {
-              ret = prevTokenizer.apply(tokenizer, args);
-            }
-            return ret;
-          };
-        }
-        opts.tokenizer = tokenizer;
-      }
-      // ==-- Parse Hooks extensions --== //
-      if (pack.hooks) {
-        const hooks = this.defaults.hooks || new _Hooks();
-        for (const prop in pack.hooks) {
-          if (!(prop in hooks)) {
-            throw new Error(`hook '${prop}' does not exist`);
-          }
-          if (['options', 'block'].includes(prop)) {
-            // ignore options and block properties
-            continue;
-          }
-          const hooksProp = prop;
-          const hooksFunc = pack.hooks[hooksProp];
-          const prevHook = hooks[hooksProp];
-          if (_Hooks.passThroughHooks.has(prop)) {
-            // @ts-expect-error cannot type hook function dynamically
-            hooks[hooksProp] = arg => {
-              if (this.defaults.async) {
-                return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {
-                  return prevHook.call(hooks, ret);
-                });
-              }
-              const ret = hooksFunc.call(hooks, arg);
-              return prevHook.call(hooks, ret);
-            };
-          } else {
-            // @ts-expect-error cannot type hook function dynamically
-            hooks[hooksProp] = (...args) => {
-              let ret = hooksFunc.apply(hooks, args);
-              if (ret === false) {
-                ret = prevHook.apply(hooks, args);
-              }
-              return ret;
-            };
-          }
-        }
-        opts.hooks = hooks;
-      }
-      // ==-- Parse WalkTokens extensions --== //
-      if (pack.walkTokens) {
-        const walkTokens = this.defaults.walkTokens;
-        const packWalktokens = pack.walkTokens;
-        opts.walkTokens = function (token) {
-          let values = [];
-          values.push(packWalktokens.call(this, token));
-          if (walkTokens) {
-            values = values.concat(walkTokens.call(this, token));
-          }
-          return values;
-        };
-      }
-      this.defaults = {
-        ...this.defaults,
-        ...opts
-      };
-    });
-    return this;
-  }
-  setOptions(opt) {
-    this.defaults = {
-      ...this.defaults,
-      ...opt
-    };
-    return this;
-  }
-  lexer(src, options) {
-    return _Lexer.lex(src, options ?? this.defaults);
-  }
-  parser(tokens, options) {
-    return _Parser.parse(tokens, options ?? this.defaults);
-  }
-  parseMarkdown(blockType) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const parse = (src, options) => {
-      const origOpt = {
-        ...options
-      };
-      const opt = {
-        ...this.defaults,
-        ...origOpt
-      };
-      const throwError = this.onError(!!opt.silent, !!opt.async);
-      // throw error if an extension set async to true but parse was called with async: false
-      if (this.defaults.async === true && origOpt.async === false) {
-        return throwError(new Error('marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise.'));
-      }
-      // throw error in case of non string input
-      if (typeof src === 'undefined' || src === null) {
-        return throwError(new Error('marked(): input parameter is undefined or null'));
-      }
-      if (typeof src !== 'string') {
-        return throwError(new Error('marked(): input parameter is of type ' + Object.prototype.toString.call(src) + ', string expected'));
-      }
-      if (opt.hooks) {
-        opt.hooks.options = opt;
-        opt.hooks.block = blockType;
-      }
-      const lexer = opt.hooks ? opt.hooks.provideLexer() : blockType ? _Lexer.lex : _Lexer.lexInline;
-      const parser = opt.hooks ? opt.hooks.provideParser() : blockType ? _Parser.parse : _Parser.parseInline;
-      if (opt.async) {
-        return Promise.resolve(opt.hooks ? opt.hooks.preprocess(src) : src).then(src => lexer(src, opt)).then(tokens => opt.hooks ? opt.hooks.processAllTokens(tokens) : tokens).then(tokens => opt.walkTokens ? Promise.all(this.walkTokens(tokens, opt.walkTokens)).then(() => tokens) : tokens).then(tokens => parser(tokens, opt)).then(html => opt.hooks ? opt.hooks.postprocess(html) : html).catch(throwError);
-      }
-      try {
-        if (opt.hooks) {
-          src = opt.hooks.preprocess(src);
-        }
-        let tokens = lexer(src, opt);
-        if (opt.hooks) {
-          tokens = opt.hooks.processAllTokens(tokens);
-        }
-        if (opt.walkTokens) {
-          this.walkTokens(tokens, opt.walkTokens);
-        }
-        let html = parser(tokens, opt);
-        if (opt.hooks) {
-          html = opt.hooks.postprocess(html);
-        }
-        return html;
-      } catch (e) {
-        return throwError(e);
-      }
-    };
-    return parse;
-  }
-  onError(silent, async) {
-    return e => {
-      e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-      if (silent) {
-        const msg = '<p>An error occurred:</p><pre>' + escape(e.message + '', true) + '</pre>';
-        if (async) {
-          return Promise.resolve(msg);
-        }
-        return msg;
-      }
-      if (async) {
-        return Promise.reject(e);
-      }
-      throw e;
-    };
-  }
-}
-const markedInstance = new Marked();
-function marked(src, opt) {
-  return markedInstance.parse(src, opt);
-}
-/**
- * Sets the default options.
- *
- * @param options Hash of options
- */
-marked.options = marked.setOptions = function (options) {
-  markedInstance.setOptions(options);
-  marked.defaults = markedInstance.defaults;
-  changeDefaults(marked.defaults);
-  return marked;
-};
-/**
- * Gets the original marked default options.
- */
-marked.getDefaults = _getDefaults;
-marked.defaults = _defaults;
-/**
- * Use Extension
- */
-marked.use = function (...args) {
-  markedInstance.use(...args);
-  marked.defaults = markedInstance.defaults;
-  changeDefaults(marked.defaults);
-  return marked;
-};
-/**
- * Run callback for every token
- */
-marked.walkTokens = function (tokens, callback) {
-  return markedInstance.walkTokens(tokens, callback);
-};
-/**
- * Compiles markdown to HTML without enclosing `p` tag.
- *
- * @param src String of markdown source to be compiled
- * @param options Hash of options
- * @return String of compiled HTML
- */
-marked.parseInline = markedInstance.parseInline;
-/**
- * Expose
- */
-marked.Parser = _Parser;
-marked.parser = _Parser.parse;
-marked.Renderer = _Renderer;
-marked.TextRenderer = _TextRenderer;
-marked.Lexer = _Lexer;
-marked.lexer = _Lexer.lex;
-marked.Tokenizer = _Tokenizer;
-marked.Hooks = _Hooks;
-marked.parse = marked;
-
-const renderMarkdown = async (markdown, options = {}) => {
-  const html = await marked(markdown, {});
-  return html;
-};
-
-const terminate = () => {
-  globalThis.close();
-};
-
-const commandMap = {
-  'Markdown.getVirtualDom': getMarkdownVirtualDom,
-  'Markdown.render': renderMarkdown,
-  'Markdown.terminate': terminate,
-  // deprecated
-  'Markdown.renderMarkdown': renderMarkdown,
-  'Markdown.getMarkDownVirtualDom': getMarkdownVirtualDom
-};
-
-const RendererWorker = 1;
-
-const rpcs = Object.create(null);
-const set = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-
-const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMap
-  });
-  set(RendererWorker, rpc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();