@4djs/assistant 0.1.1 → 0.1.2

package/dist/core/index.js

@@ -16,835 +16,1425 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-// ../../node_modules/.bun/react@19.2.7/node_modules/react/cjs/react.development.js
-var require_react_development = __commonJS((exports, module) => {
-  (function() {
-    function defineDeprecationWarning(methodName, info) {
-      Object.defineProperty(Component.prototype, methodName, {
-        get: function() {
-          console.warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
-        }
-      });
+// ../../node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/lib/core.js
+var require_core = __commonJS((exports, module) => {
+  function deepFreeze(obj) {
+    if (obj instanceof Map) {
+      obj.clear = obj.delete = obj.set = function() {
+        throw new Error("map is read-only");
+      };
+    } else if (obj instanceof Set) {
+      obj.add = obj.clear = obj.delete = function() {
+        throw new Error("set is read-only");
+      };
     }
-    function getIteratorFn(maybeIterable) {
-      if (maybeIterable === null || typeof maybeIterable !== "object")
-        return null;
-      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
-      return typeof maybeIterable === "function" ? maybeIterable : null;
-    }
-    function warnNoop(publicInstance, callerName) {
-      publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
-      var warningKey = publicInstance + "." + callerName;
-      didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", callerName, publicInstance), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
-    }
-    function Component(props, context, updater) {
-      this.props = props;
-      this.context = context;
-      this.refs = emptyObject;
-      this.updater = updater || ReactNoopUpdateQueue;
-    }
-    function ComponentDummy() {}
-    function PureComponent(props, context, updater) {
-      this.props = props;
-      this.context = context;
-      this.refs = emptyObject;
-      this.updater = updater || ReactNoopUpdateQueue;
-    }
-    function noop() {}
-    function testStringCoercion(value) {
-      return "" + value;
-    }
-    function checkKeyStringCoercion(value) {
-      try {
-        testStringCoercion(value);
-        var JSCompiler_inline_result = false;
-      } catch (e) {
-        JSCompiler_inline_result = true;
+    Object.freeze(obj);
+    Object.getOwnPropertyNames(obj).forEach((name) => {
+      const prop = obj[name];
+      const type = typeof prop;
+      if ((type === "object" || type === "function") && !Object.isFrozen(prop)) {
+        deepFreeze(prop);
       }
-      if (JSCompiler_inline_result) {
-        JSCompiler_inline_result = console;
-        var JSCompiler_temp_const = JSCompiler_inline_result.error;
-        var JSCompiler_inline_result$jscomp$0 = typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
-        JSCompiler_temp_const.call(JSCompiler_inline_result, "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.", JSCompiler_inline_result$jscomp$0);
-        return testStringCoercion(value);
+    });
+    return obj;
+  }
+
+  class Response {
+    constructor(mode) {
+      if (mode.data === undefined)
+        mode.data = {};
+      this.data = mode.data;
+      this.isMatchIgnored = false;
+    }
+    ignoreMatch() {
+      this.isMatchIgnored = true;
+    }
+  }
+  function escapeHTML(value) {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+  }
+  function inherit$1(original, ...objects) {
+    const result = Object.create(null);
+    for (const key in original) {
+      result[key] = original[key];
+    }
+    objects.forEach(function(obj) {
+      for (const key in obj) {
+        result[key] = obj[key];
       }
+    });
+    return result;
+  }
+  var SPAN_CLOSE = "</span>";
+  var emitsWrappingTags = (node) => {
+    return !!node.scope;
+  };
+  var scopeToCSSClass = (name, { prefix }) => {
+    if (name.startsWith("language:")) {
+      return name.replace("language:", "language-");
     }
-    function getComponentNameFromType(type) {
-      if (type == null)
-        return null;
-      if (typeof type === "function")
-        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
-      if (typeof type === "string")
-        return type;
-      switch (type) {
-        case REACT_FRAGMENT_TYPE:
-          return "Fragment";
-        case REACT_PROFILER_TYPE:
-          return "Profiler";
-        case REACT_STRICT_MODE_TYPE:
-          return "StrictMode";
-        case REACT_SUSPENSE_TYPE:
-          return "Suspense";
-        case REACT_SUSPENSE_LIST_TYPE:
-          return "SuspenseList";
-        case REACT_ACTIVITY_TYPE:
-          return "Activity";
-      }
-      if (typeof type === "object")
-        switch (typeof type.tag === "number" && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
-          case REACT_PORTAL_TYPE:
-            return "Portal";
-          case REACT_CONTEXT_TYPE:
-            return type.displayName || "Context";
-          case REACT_CONSUMER_TYPE:
-            return (type._context.displayName || "Context") + ".Consumer";
-          case REACT_FORWARD_REF_TYPE:
-            var innerType = type.render;
-            type = type.displayName;
-            type || (type = innerType.displayName || innerType.name || "", type = type !== "" ? "ForwardRef(" + type + ")" : "ForwardRef");
-            return type;
-          case REACT_MEMO_TYPE:
-            return innerType = type.displayName || null, innerType !== null ? innerType : getComponentNameFromType(type.type) || "Memo";
-          case REACT_LAZY_TYPE:
-            innerType = type._payload;
-            type = type._init;
-            try {
-              return getComponentNameFromType(type(innerType));
-            } catch (x) {}
-        }
-      return null;
+    if (name.includes(".")) {
+      const pieces = name.split(".");
+      return [
+        `${prefix}${pieces.shift()}`,
+        ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
+      ].join(" ");
     }
-    function getTaskName(type) {
-      if (type === REACT_FRAGMENT_TYPE)
-        return "<>";
-      if (typeof type === "object" && type !== null && type.$$typeof === REACT_LAZY_TYPE)
-        return "<...>";
-      try {
-        var name = getComponentNameFromType(type);
-        return name ? "<" + name + ">" : "<...>";
-      } catch (x) {
-        return "<...>";
+    return `${prefix}${name}`;
+  };
+
+  class HTMLRenderer {
+    constructor(parseTree, options) {
+      this.buffer = "";
+      this.classPrefix = options.classPrefix;
+      parseTree.walk(this);
+    }
+    addText(text) {
+      this.buffer += escapeHTML(text);
+    }
+    openNode(node) {
+      if (!emitsWrappingTags(node))
+        return;
+      const className = scopeToCSSClass(node.scope, { prefix: this.classPrefix });
+      this.span(className);
+    }
+    closeNode(node) {
+      if (!emitsWrappingTags(node))
+        return;
+      this.buffer += SPAN_CLOSE;
+    }
+    value() {
+      return this.buffer;
+    }
+    span(className) {
+      this.buffer += `<span class="${className}">`;
+    }
+  }
+  var newNode = (opts = {}) => {
+    const result = { children: [] };
+    Object.assign(result, opts);
+    return result;
+  };
+
+  class TokenTree {
+    constructor() {
+      this.rootNode = newNode();
+      this.stack = [this.rootNode];
+    }
+    get top() {
+      return this.stack[this.stack.length - 1];
+    }
+    get root() {
+      return this.rootNode;
+    }
+    add(node) {
+      this.top.children.push(node);
+    }
+    openNode(scope) {
+      const node = newNode({ scope });
+      this.add(node);
+      this.stack.push(node);
+    }
+    closeNode() {
+      if (this.stack.length > 1) {
+        return this.stack.pop();
       }
+      return;
     }
-    function getOwner() {
-      var dispatcher = ReactSharedInternals.A;
-      return dispatcher === null ? null : dispatcher.getOwner();
+    closeAllNodes() {
+      while (this.closeNode())
+        ;
     }
-    function UnknownOwner() {
-      return Error("react-stack-top-frame");
+    toJSON() {
+      return JSON.stringify(this.rootNode, null, 4);
     }
-    function hasValidKey(config) {
-      if (hasOwnProperty.call(config, "key")) {
-        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
-        if (getter && getter.isReactWarning)
-          return false;
+    walk(builder) {
+      return this.constructor._walk(builder, this.rootNode);
+    }
+    static _walk(builder, node) {
+      if (typeof node === "string") {
+        builder.addText(node);
+      } else if (node.children) {
+        builder.openNode(node);
+        node.children.forEach((child) => this._walk(builder, child));
+        builder.closeNode(node);
       }
-      return config.key !== undefined;
+      return builder;
     }
-    function defineKeyPropWarningGetter(props, displayName) {
-      function warnAboutAccessingKey() {
-        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)", displayName));
+    static _collapse(node) {
+      if (typeof node === "string")
+        return;
+      if (!node.children)
+        return;
+      if (node.children.every((el) => typeof el === "string")) {
+        node.children = [node.children.join("")];
+      } else {
+        node.children.forEach((child) => {
+          TokenTree._collapse(child);
+        });
       }
-      warnAboutAccessingKey.isReactWarning = true;
-      Object.defineProperty(props, "key", {
-        get: warnAboutAccessingKey,
-        configurable: true
-      });
     }
-    function elementRefGetterWithDeprecationWarning() {
-      var componentName = getComponentNameFromType(this.type);
-      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error("Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."));
-      componentName = this.props.ref;
-      return componentName !== undefined ? componentName : null;
-    }
-    function ReactElement(type, key, props, owner, debugStack, debugTask) {
-      var refProp = props.ref;
-      type = {
-        $$typeof: REACT_ELEMENT_TYPE,
-        type,
-        key,
-        props,
-        _owner: owner
-      };
-      (refProp !== undefined ? refProp : null) !== null ? Object.defineProperty(type, "ref", {
-        enumerable: false,
-        get: elementRefGetterWithDeprecationWarning
-      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
-      type._store = {};
-      Object.defineProperty(type._store, "validated", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: 0
-      });
-      Object.defineProperty(type, "_debugInfo", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: null
-      });
-      Object.defineProperty(type, "_debugStack", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugStack
+  }
+
+  class TokenTreeEmitter extends TokenTree {
+    constructor(options) {
+      super();
+      this.options = options;
+    }
+    addText(text) {
+      if (text === "") {
+        return;
+      }
+      this.add(text);
+    }
+    startScope(scope) {
+      this.openNode(scope);
+    }
+    endScope() {
+      this.closeNode();
+    }
+    __addSublanguage(emitter, name) {
+      const node = emitter.root;
+      if (name)
+        node.scope = `language:${name}`;
+      this.add(node);
+    }
+    toHTML() {
+      const renderer = new HTMLRenderer(this, this.options);
+      return renderer.value();
+    }
+    finalize() {
+      this.closeAllNodes();
+      return true;
+    }
+  }
+  function source(re) {
+    if (!re)
+      return null;
+    if (typeof re === "string")
+      return re;
+    return re.source;
+  }
+  function lookahead(re) {
+    return concat("(?=", re, ")");
+  }
+  function anyNumberOfTimes(re) {
+    return concat("(?:", re, ")*");
+  }
+  function optional(re) {
+    return concat("(?:", re, ")?");
+  }
+  function concat(...args) {
+    const joined = args.map((x) => source(x)).join("");
+    return joined;
+  }
+  function stripOptionsFromArgs(args) {
+    const opts = args[args.length - 1];
+    if (typeof opts === "object" && opts.constructor === Object) {
+      args.splice(args.length - 1, 1);
+      return opts;
+    } else {
+      return {};
+    }
+  }
+  function either(...args) {
+    const opts = stripOptionsFromArgs(args);
+    const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+    return joined;
+  }
+  function countMatchGroups(re) {
+    return new RegExp(re.toString() + "|").exec("").length - 1;
+  }
+  function startsWith(re, lexeme) {
+    const match = re && re.exec(lexeme);
+    return match && match.index === 0;
+  }
+  var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+  function _rewriteBackreferences(regexps, { joinWith }) {
+    let numCaptures = 0;
+    return regexps.map((regex) => {
+      numCaptures += 1;
+      const offset = numCaptures;
+      let re = source(regex);
+      let out = "";
+      while (re.length > 0) {
+        const match = BACKREF_RE.exec(re);
+        if (!match) {
+          out += re;
+          break;
+        }
+        out += re.substring(0, match.index);
+        re = re.substring(match.index + match[0].length);
+        if (match[0][0] === "\\" && match[1]) {
+          out += "\\" + String(Number(match[1]) + offset);
+        } else {
+          out += match[0];
+          if (match[0] === "(") {
+            numCaptures++;
+          }
+        }
+      }
+      return out;
+    }).map((re) => `(${re})`).join(joinWith);
+  }
+  var MATCH_NOTHING_RE = /\b\B/;
+  var IDENT_RE = "[a-zA-Z]\\w*";
+  var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*";
+  var NUMBER_RE = "\\b\\d+(\\.\\d+)?";
+  var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";
+  var BINARY_NUMBER_RE = "\\b(0b[01]+)";
+  var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";
+  var SHEBANG = (opts = {}) => {
+    const beginShebang = /^#![ ]*\//;
+    if (opts.binary) {
+      opts.begin = concat(beginShebang, /.*\b/, opts.binary, /\b.*/);
+    }
+    return inherit$1({
+      scope: "meta",
+      begin: beginShebang,
+      end: /$/,
+      relevance: 0,
+      "on:begin": (m, resp) => {
+        if (m.index !== 0)
+          resp.ignoreMatch();
+      }
+    }, opts);
+  };
+  var BACKSLASH_ESCAPE = {
+    begin: "\\\\[\\s\\S]",
+    relevance: 0
+  };
+  var APOS_STRING_MODE = {
+    scope: "string",
+    begin: "'",
+    end: "'",
+    illegal: "\\n",
+    contains: [BACKSLASH_ESCAPE]
+  };
+  var QUOTE_STRING_MODE = {
+    scope: "string",
+    begin: '"',
+    end: '"',
+    illegal: "\\n",
+    contains: [BACKSLASH_ESCAPE]
+  };
+  var PHRASAL_WORDS_MODE = {
+    begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+  };
+  var COMMENT = function(begin, end, modeOptions = {}) {
+    const mode = inherit$1({
+      scope: "comment",
+      begin,
+      end,
+      contains: []
+    }, modeOptions);
+    mode.contains.push({
+      scope: "doctag",
+      begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+      end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+      excludeBegin: true,
+      relevance: 0
+    });
+    const ENGLISH_WORD = either("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/);
+    mode.contains.push({
+      begin: concat(/[ ]+/, "(", ENGLISH_WORD, /[.]?[:]?([.][ ]|[ ])/, "){3}")
+    });
+    return mode;
+  };
+  var C_LINE_COMMENT_MODE = COMMENT("//", "$");
+  var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/");
+  var HASH_COMMENT_MODE = COMMENT("#", "$");
+  var NUMBER_MODE = {
+    scope: "number",
+    begin: NUMBER_RE,
+    relevance: 0
+  };
+  var C_NUMBER_MODE = {
+    scope: "number",
+    begin: C_NUMBER_RE,
+    relevance: 0
+  };
+  var BINARY_NUMBER_MODE = {
+    scope: "number",
+    begin: BINARY_NUMBER_RE,
+    relevance: 0
+  };
+  var REGEXP_MODE = {
+    scope: "regexp",
+    begin: /\/(?=[^/\n]*\/)/,
+    end: /\/[gimuy]*/,
+    contains: [
+      BACKSLASH_ESCAPE,
+      {
+        begin: /\[/,
+        end: /\]/,
+        relevance: 0,
+        contains: [BACKSLASH_ESCAPE]
+      }
+    ]
+  };
+  var TITLE_MODE = {
+    scope: "title",
+    begin: IDENT_RE,
+    relevance: 0
+  };
+  var UNDERSCORE_TITLE_MODE = {
+    scope: "title",
+    begin: UNDERSCORE_IDENT_RE,
+    relevance: 0
+  };
+  var METHOD_GUARD = {
+    begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
+    relevance: 0
+  };
+  var END_SAME_AS_BEGIN = function(mode) {
+    return Object.assign(mode, {
+      "on:begin": (m, resp) => {
+        resp.data._beginMatch = m[1];
+      },
+      "on:end": (m, resp) => {
+        if (resp.data._beginMatch !== m[1])
+          resp.ignoreMatch();
+      }
+    });
+  };
+  var MODES = /* @__PURE__ */ Object.freeze({
+    __proto__: null,
+    APOS_STRING_MODE,
+    BACKSLASH_ESCAPE,
+    BINARY_NUMBER_MODE,
+    BINARY_NUMBER_RE,
+    COMMENT,
+    C_BLOCK_COMMENT_MODE,
+    C_LINE_COMMENT_MODE,
+    C_NUMBER_MODE,
+    C_NUMBER_RE,
+    END_SAME_AS_BEGIN,
+    HASH_COMMENT_MODE,
+    IDENT_RE,
+    MATCH_NOTHING_RE,
+    METHOD_GUARD,
+    NUMBER_MODE,
+    NUMBER_RE,
+    PHRASAL_WORDS_MODE,
+    QUOTE_STRING_MODE,
+    REGEXP_MODE,
+    RE_STARTERS_RE,
+    SHEBANG,
+    TITLE_MODE,
+    UNDERSCORE_IDENT_RE,
+    UNDERSCORE_TITLE_MODE
+  });
+  function skipIfHasPrecedingDot(match, response) {
+    const before = match.input[match.index - 1];
+    if (before === ".") {
+      response.ignoreMatch();
+    }
+  }
+  function scopeClassName(mode, _parent) {
+    if (mode.className !== undefined) {
+      mode.scope = mode.className;
+      delete mode.className;
+    }
+  }
+  function beginKeywords(mode, parent) {
+    if (!parent)
+      return;
+    if (!mode.beginKeywords)
+      return;
+    mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)";
+    mode.__beforeBegin = skipIfHasPrecedingDot;
+    mode.keywords = mode.keywords || mode.beginKeywords;
+    delete mode.beginKeywords;
+    if (mode.relevance === undefined)
+      mode.relevance = 0;
+  }
+  function compileIllegal(mode, _parent) {
+    if (!Array.isArray(mode.illegal))
+      return;
+    mode.illegal = either(...mode.illegal);
+  }
+  function compileMatch(mode, _parent) {
+    if (!mode.match)
+      return;
+    if (mode.begin || mode.end)
+      throw new Error("begin & end are not supported with match");
+    mode.begin = mode.match;
+    delete mode.match;
+  }
+  function compileRelevance(mode, _parent) {
+    if (mode.relevance === undefined)
+      mode.relevance = 1;
+  }
+  var beforeMatchExt = (mode, parent) => {
+    if (!mode.beforeMatch)
+      return;
+    if (mode.starts)
+      throw new Error("beforeMatch cannot be used with starts");
+    const originalMode = Object.assign({}, mode);
+    Object.keys(mode).forEach((key) => {
+      delete mode[key];
+    });
+    mode.keywords = originalMode.keywords;
+    mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+    mode.starts = {
+      relevance: 0,
+      contains: [
+        Object.assign(originalMode, { endsParent: true })
+      ]
+    };
+    mode.relevance = 0;
+    delete originalMode.beforeMatch;
+  };
+  var COMMON_KEYWORDS = [
+    "of",
+    "and",
+    "for",
+    "in",
+    "not",
+    "or",
+    "if",
+    "then",
+    "parent",
+    "list",
+    "value"
+  ];
+  var DEFAULT_KEYWORD_SCOPE = "keyword";
+  function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+    const compiledKeywords = Object.create(null);
+    if (typeof rawKeywords === "string") {
+      compileList(scopeName, rawKeywords.split(" "));
+    } else if (Array.isArray(rawKeywords)) {
+      compileList(scopeName, rawKeywords);
+    } else {
+      Object.keys(rawKeywords).forEach(function(scopeName2) {
+        Object.assign(compiledKeywords, compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2));
       });
-      Object.defineProperty(type, "_debugTask", {
-        configurable: false,
-        enumerable: false,
-        writable: true,
-        value: debugTask
+    }
+    return compiledKeywords;
+    function compileList(scopeName2, keywordList) {
+      if (caseInsensitive) {
+        keywordList = keywordList.map((x) => x.toLowerCase());
+      }
+      keywordList.forEach(function(keyword) {
+        const pair = keyword.split("|");
+        compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])];
       });
-      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
-      return type;
     }
-    function cloneAndReplaceKey(oldElement, newKey) {
-      newKey = ReactElement(oldElement.type, newKey, oldElement.props, oldElement._owner, oldElement._debugStack, oldElement._debugTask);
-      oldElement._store && (newKey._store.validated = oldElement._store.validated);
-      return newKey;
+  }
+  function scoreForKeyword(keyword, providedScore) {
+    if (providedScore) {
+      return Number(providedScore);
+    }
+    return commonKeyword(keyword) ? 0 : 1;
+  }
+  function commonKeyword(keyword) {
+    return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+  }
+  var seenDeprecations = {};
+  var error = (message) => {
+    console.error(message);
+  };
+  var warn = (message, ...args) => {
+    console.log(`WARN: ${message}`, ...args);
+  };
+  var deprecated = (version2, message) => {
+    if (seenDeprecations[`${version2}/${message}`])
+      return;
+    console.log(`Deprecated as of ${version2}. ${message}`);
+    seenDeprecations[`${version2}/${message}`] = true;
+  };
+  var MultiClassError = new Error;
+  function remapScopeNames(mode, regexes, { key }) {
+    let offset = 0;
+    const scopeNames = mode[key];
+    const emit = {};
+    const positions = {};
+    for (let i = 1;i <= regexes.length; i++) {
+      positions[i + offset] = scopeNames[i];
+      emit[i + offset] = true;
+      offset += countMatchGroups(regexes[i - 1]);
+    }
+    mode[key] = positions;
+    mode[key]._emit = emit;
+    mode[key]._multi = true;
+  }
+  function beginMultiClass(mode) {
+    if (!Array.isArray(mode.begin))
+      return;
+    if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+      error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+      throw MultiClassError;
     }
-    function validateChildKeys(node) {
-      isValidElement(node) ? node._store && (node._store.validated = 1) : typeof node === "object" && node !== null && node.$$typeof === REACT_LAZY_TYPE && (node._payload.status === "fulfilled" ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+      error("beginScope must be object");
+      throw MultiClassError;
     }
-    function isValidElement(object) {
-      return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+    remapScopeNames(mode, mode.begin, { key: "beginScope" });
+    mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+  }
+  function endMultiClass(mode) {
+    if (!Array.isArray(mode.end))
+      return;
+    if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+      error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+      throw MultiClassError;
     }
-    function escape(key) {
-      var escaperLookup = { "=": "=0", ":": "=2" };
-      return "$" + key.replace(/[=:]/g, function(match) {
-        return escaperLookup[match];
-      });
+    if (typeof mode.endScope !== "object" || mode.endScope === null) {
+      error("endScope must be object");
+      throw MultiClassError;
+    }
+    remapScopeNames(mode, mode.end, { key: "endScope" });
+    mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+  }
+  function scopeSugar(mode) {
+    if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+      mode.beginScope = mode.scope;
+      delete mode.scope;
+    }
+  }
+  function MultiClass(mode) {
+    scopeSugar(mode);
+    if (typeof mode.beginScope === "string") {
+      mode.beginScope = { _wrap: mode.beginScope };
+    }
+    if (typeof mode.endScope === "string") {
+      mode.endScope = { _wrap: mode.endScope };
+    }
+    beginMultiClass(mode);
+    endMultiClass(mode);
+  }
+  function compileLanguage(language) {
+    function langRe(value, global) {
+      return new RegExp(source(value), "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : ""));
+    }
+
+    class MultiRegex {
+      constructor() {
+        this.matchIndexes = {};
+        this.regexes = [];
+        this.matchAt = 1;
+        this.position = 0;
+      }
+      addRule(re, opts) {
+        opts.position = this.position++;
+        this.matchIndexes[this.matchAt] = opts;
+        this.regexes.push([opts, re]);
+        this.matchAt += countMatchGroups(re) + 1;
+      }
+      compile() {
+        if (this.regexes.length === 0) {
+          this.exec = () => null;
+        }
+        const terminators = this.regexes.map((el) => el[1]);
+        this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true);
+        this.lastIndex = 0;
+      }
+      exec(s) {
+        this.matcherRe.lastIndex = this.lastIndex;
+        const match = this.matcherRe.exec(s);
+        if (!match) {
+          return null;
+        }
+        const i = match.findIndex((el, i2) => i2 > 0 && el !== undefined);
+        const matchData = this.matchIndexes[i];
+        match.splice(0, i);
+        return Object.assign(match, matchData);
+      }
     }
-    function getElementKey(element, index) {
-      return typeof element === "object" && element !== null && element.key != null ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
-    }
-    function resolveThenable(thenable) {
-      switch (thenable.status) {
-        case "fulfilled":
-          return thenable.value;
-        case "rejected":
-          throw thenable.reason;
-        default:
-          switch (typeof thenable.status === "string" ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(function(fulfilledValue) {
-            thenable.status === "pending" && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
-          }, function(error) {
-            thenable.status === "pending" && (thenable.status = "rejected", thenable.reason = error);
-          })), thenable.status) {
-            case "fulfilled":
-              return thenable.value;
-            case "rejected":
-              throw thenable.reason;
+
+    class ResumableMultiRegex {
+      constructor() {
+        this.rules = [];
+        this.multiRegexes = [];
+        this.count = 0;
+        this.lastIndex = 0;
+        this.regexIndex = 0;
+      }
+      getMatcher(index) {
+        if (this.multiRegexes[index])
+          return this.multiRegexes[index];
+        const matcher = new MultiRegex;
+        this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+        matcher.compile();
+        this.multiRegexes[index] = matcher;
+        return matcher;
+      }
+      resumingScanAtSamePosition() {
+        return this.regexIndex !== 0;
+      }
+      considerAll() {
+        this.regexIndex = 0;
+      }
+      addRule(re, opts) {
+        this.rules.push([re, opts]);
+        if (opts.type === "begin")
+          this.count++;
+      }
+      exec(s) {
+        const m = this.getMatcher(this.regexIndex);
+        m.lastIndex = this.lastIndex;
+        let result = m.exec(s);
+        if (this.resumingScanAtSamePosition()) {
+          if (result && result.index === this.lastIndex)
+            ;
+          else {
+            const m2 = this.getMatcher(0);
+            m2.lastIndex = this.lastIndex + 1;
+            result = m2.exec(s);
+          }
+        }
+        if (result) {
+          this.regexIndex += result.position + 1;
+          if (this.regexIndex === this.count) {
+            this.considerAll();
           }
+        }
+        return result;
       }
-      throw thenable;
-    }
-    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
-      var type = typeof children;
-      if (type === "undefined" || type === "boolean")
-        children = null;
-      var invokeCallback = false;
-      if (children === null)
-        invokeCallback = true;
-      else
-        switch (type) {
-          case "bigint":
-          case "string":
-          case "number":
-            invokeCallback = true;
-            break;
-          case "object":
-            switch (children.$$typeof) {
-              case REACT_ELEMENT_TYPE:
-              case REACT_PORTAL_TYPE:
-                invokeCallback = true;
-                break;
-              case REACT_LAZY_TYPE:
-                return invokeCallback = children._init, mapIntoArray(invokeCallback(children._payload), array, escapedPrefix, nameSoFar, callback);
-            }
+    }
+    function buildModeRegex(mode) {
+      const mm = new ResumableMultiRegex;
+      mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" }));
+      if (mode.terminatorEnd) {
+        mm.addRule(mode.terminatorEnd, { type: "end" });
+      }
+      if (mode.illegal) {
+        mm.addRule(mode.illegal, { type: "illegal" });
+      }
+      return mm;
+    }
+    function compileMode(mode, parent) {
+      const cmode = mode;
+      if (mode.isCompiled)
+        return cmode;
+      [
+        scopeClassName,
+        compileMatch,
+        MultiClass,
+        beforeMatchExt
+      ].forEach((ext) => ext(mode, parent));
+      language.compilerExtensions.forEach((ext) => ext(mode, parent));
+      mode.__beforeBegin = null;
+      [
+        beginKeywords,
+        compileIllegal,
+        compileRelevance
+      ].forEach((ext) => ext(mode, parent));
+      mode.isCompiled = true;
+      let keywordPattern = null;
+      if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+        mode.keywords = Object.assign({}, mode.keywords);
+        keywordPattern = mode.keywords.$pattern;
+        delete mode.keywords.$pattern;
+      }
+      keywordPattern = keywordPattern || /\w+/;
+      if (mode.keywords) {
+        mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+      }
+      cmode.keywordPatternRe = langRe(keywordPattern, true);
+      if (parent) {
+        if (!mode.begin)
+          mode.begin = /\B|\b/;
+        cmode.beginRe = langRe(cmode.begin);
+        if (!mode.end && !mode.endsWithParent)
+          mode.end = /\B|\b/;
+        if (mode.end)
+          cmode.endRe = langRe(cmode.end);
+        cmode.terminatorEnd = source(cmode.end) || "";
+        if (mode.endsWithParent && parent.terminatorEnd) {
+          cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
         }
-      if (invokeCallback) {
-        invokeCallback = children;
-        callback = callback(invokeCallback);
-        var childKey = nameSoFar === "" ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
-        isArrayImpl(callback) ? (escapedPrefix = "", childKey != null && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
-          return c;
-        })) : callback != null && (isValidElement(callback) && (callback.key != null && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(callback, escapedPrefix + (callback.key == null || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(userProvidedKeyEscapeRegex, "$&/") + "/") + childKey), nameSoFar !== "" && invokeCallback != null && isValidElement(invokeCallback) && invokeCallback.key == null && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
-        return 1;
-      }
-      invokeCallback = 0;
-      childKey = nameSoFar === "" ? "." : nameSoFar + ":";
-      if (isArrayImpl(children))
-        for (var i = 0;i < children.length; i++)
-          nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
-      else if (i = getIteratorFn(children), typeof i === "function")
-        for (i === children.entries && (didWarnAboutMaps || console.warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), didWarnAboutMaps = true), children = i.call(children), i = 0;!(nameSoFar = children.next()).done; )
-          nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(nameSoFar, array, escapedPrefix, type, callback);
-      else if (type === "object") {
-        if (typeof children.then === "function")
-          return mapIntoArray(resolveThenable(children), array, escapedPrefix, nameSoFar, callback);
-        array = String(children);
-        throw Error("Objects are not valid as a React child (found: " + (array === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead.");
-      }
-      return invokeCallback;
-    }
-    function mapChildren(children, func, context) {
-      if (children == null)
-        return children;
-      var result = [], count = 0;
-      mapIntoArray(children, result, "", "", function(child) {
-        return func.call(context, child, count++);
+      }
+      if (mode.illegal)
+        cmode.illegalRe = langRe(mode.illegal);
+      if (!mode.contains)
+        mode.contains = [];
+      mode.contains = [].concat(...mode.contains.map(function(c) {
+        return expandOrCloneMode(c === "self" ? mode : c);
+      }));
+      mode.contains.forEach(function(c) {
+        compileMode(c, cmode);
+      });
+      if (mode.starts) {
+        compileMode(mode.starts, parent);
+      }
+      cmode.matcher = buildModeRegex(cmode);
+      return cmode;
+    }
+    if (!language.compilerExtensions)
+      language.compilerExtensions = [];
+    if (language.contains && language.contains.includes("self")) {
+      throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+    }
+    language.classNameAliases = inherit$1(language.classNameAliases || {});
+    return compileMode(language);
+  }
+  function dependencyOnParent(mode) {
+    if (!mode)
+      return false;
+    return mode.endsWithParent || dependencyOnParent(mode.starts);
+  }
+  function expandOrCloneMode(mode) {
+    if (mode.variants && !mode.cachedVariants) {
+      mode.cachedVariants = mode.variants.map(function(variant) {
+        return inherit$1(mode, { variants: null }, variant);
       });
+    }
+    if (mode.cachedVariants) {
+      return mode.cachedVariants;
+    }
+    if (dependencyOnParent(mode)) {
+      return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+    }
+    if (Object.isFrozen(mode)) {
+      return inherit$1(mode);
+    }
+    return mode;
+  }
+  var version = "11.11.1";
+
+  class HTMLInjectionError extends Error {
+    constructor(reason, html) {
+      super(reason);
+      this.name = "HTMLInjectionError";
+      this.html = html;
+    }
+  }
+  var escape = escapeHTML;
+  var inherit = inherit$1;
+  var NO_MATCH = Symbol("nomatch");
+  var MAX_KEYWORD_HITS = 7;
+  var HLJS = function(hljs) {
+    const languages = Object.create(null);
+    const aliases = Object.create(null);
+    const plugins = [];
+    let SAFE_MODE = true;
+    const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+    const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] };
+    let options = {
+      ignoreUnescapedHTML: false,
+      throwUnescapedHTML: false,
+      noHighlightRe: /^(no-?highlight)$/i,
+      languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+      classPrefix: "hljs-",
+      cssSelector: "pre code",
+      languages: null,
+      __emitter: TokenTreeEmitter
+    };
+    function shouldNotHighlight(languageName) {
+      return options.noHighlightRe.test(languageName);
+    }
+    function blockLanguage(block) {
+      let classes = block.className + " ";
+      classes += block.parentNode ? block.parentNode.className : "";
+      const match = options.languageDetectRe.exec(classes);
+      if (match) {
+        const language = getLanguage(match[1]);
+        if (!language) {
+          warn(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+          warn("Falling back to no-highlight mode for this block.", block);
+        }
+        return language ? match[1] : "no-highlight";
+      }
+      return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+    }
+    function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+      let code = "";
+      let languageName = "";
+      if (typeof optionsOrCode === "object") {
+        code = codeOrLanguageName;
+        ignoreIllegals = optionsOrCode.ignoreIllegals;
+        languageName = optionsOrCode.language;
+      } else {
+        deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+        deprecated("10.7.0", `Please use highlight(code, options) instead.
+https://github.com/highlightjs/highlight.js/issues/2277`);
+        languageName = codeOrLanguageName;
+        code = optionsOrCode;
+      }
+      if (ignoreIllegals === undefined) {
+        ignoreIllegals = true;
+      }
+      const context = {
+        code,
+        language: languageName
+      };
+      fire("before:highlight", context);
+      const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
+      result.code = context.code;
+      fire("after:highlight", result);
       return result;
     }
-    function lazyInitializer(payload) {
-      if (payload._status === -1) {
-        var ioInfo = payload._ioInfo;
-        ioInfo != null && (ioInfo.start = ioInfo.end = performance.now());
-        ioInfo = payload._result;
-        var thenable = ioInfo();
-        thenable.then(function(moduleObject) {
-          if (payload._status === 0 || payload._status === -1) {
-            payload._status = 1;
-            payload._result = moduleObject;
-            var _ioInfo = payload._ioInfo;
-            _ioInfo != null && (_ioInfo.end = performance.now());
-            thenable.status === undefined && (thenable.status = "fulfilled", thenable.value = moduleObject);
+    function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+      const keywordHits = Object.create(null);
+      function keywordData(mode, matchText) {
+        return mode.keywords[matchText];
+      }
+      function processKeywords() {
+        if (!top.keywords) {
+          emitter.addText(modeBuffer);
+          return;
+        }
+        let lastIndex = 0;
+        top.keywordPatternRe.lastIndex = 0;
+        let match = top.keywordPatternRe.exec(modeBuffer);
+        let buf = "";
+        while (match) {
+          buf += modeBuffer.substring(lastIndex, match.index);
+          const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+          const data = keywordData(top, word);
+          if (data) {
+            const [kind, keywordRelevance] = data;
+            emitter.addText(buf);
+            buf = "";
+            keywordHits[word] = (keywordHits[word] || 0) + 1;
+            if (keywordHits[word] <= MAX_KEYWORD_HITS)
+              relevance += keywordRelevance;
+            if (kind.startsWith("_")) {
+              buf += match[0];
+            } else {
+              const cssClass = language.classNameAliases[kind] || kind;
+              emitKeyword(match[0], cssClass);
+            }
+          } else {
+            buf += match[0];
           }
-        }, function(error) {
-          if (payload._status === 0 || payload._status === -1) {
-            payload._status = 2;
-            payload._result = error;
-            var _ioInfo2 = payload._ioInfo;
-            _ioInfo2 != null && (_ioInfo2.end = performance.now());
-            thenable.status === undefined && (thenable.status = "rejected", thenable.reason = error);
+          lastIndex = top.keywordPatternRe.lastIndex;
+          match = top.keywordPatternRe.exec(modeBuffer);
+        }
+        buf += modeBuffer.substring(lastIndex);
+        emitter.addText(buf);
+      }
+      function processSubLanguage() {
+        if (modeBuffer === "")
+          return;
+        let result2 = null;
+        if (typeof top.subLanguage === "string") {
+          if (!languages[top.subLanguage]) {
+            emitter.addText(modeBuffer);
+            return;
           }
-        });
-        ioInfo = payload._ioInfo;
-        if (ioInfo != null) {
-          ioInfo.value = thenable;
-          var displayName = thenable.displayName;
-          typeof displayName === "string" && (ioInfo.name = displayName);
+          result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+          continuations[top.subLanguage] = result2._top;
+        } else {
+          result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+        }
+        if (top.relevance > 0) {
+          relevance += result2.relevance;
         }
-        payload._status === -1 && (payload._status = 0, payload._result = thenable);
+        emitter.__addSublanguage(result2._emitter, result2.language);
       }
-      if (payload._status === 1)
-        return ioInfo = payload._result, ioInfo === undefined && console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
-
-Your code should look like: 
-  const MyComponent = lazy(() => import('./MyComponent'))
-
-Did you accidentally put curly braces around the import?`, ioInfo), "default" in ioInfo || console.error(`lazy: Expected the result of a dynamic import() call. Instead received: %s
-
-Your code should look like: 
-  const MyComponent = lazy(() => import('./MyComponent'))`, ioInfo), ioInfo.default;
-      throw payload._result;
-    }
-    function resolveDispatcher() {
-      var dispatcher = ReactSharedInternals.H;
-      dispatcher === null && console.error(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
-1. You might have mismatching versions of React and the renderer (such as React DOM)
-2. You might be breaking the Rules of Hooks
-3. You might have more than one copy of React in the same app
-See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`);
-      return dispatcher;
-    }
-    function releaseAsyncTransition() {
-      ReactSharedInternals.asyncTransitions--;
-    }
-    function enqueueTask(task) {
-      if (enqueueTaskImpl === null)
-        try {
-          var requireString = ("require" + Math.random()).slice(0, 7);
-          enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
-        } catch (_err) {
-          enqueueTaskImpl = function(callback) {
-            didWarnAboutMessageChannel === false && (didWarnAboutMessageChannel = true, typeof MessageChannel === "undefined" && console.error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
-            var channel = new MessageChannel;
-            channel.port1.onmessage = callback;
-            channel.port2.postMessage(undefined);
-          };
+      function processBuffer() {
+        if (top.subLanguage != null) {
+          processSubLanguage();
+        } else {
+          processKeywords();
         }
-      return enqueueTaskImpl(task);
-    }
-    function aggregateErrors(errors) {
-      return 1 < errors.length && typeof AggregateError === "function" ? new AggregateError(errors) : errors[0];
-    }
-    function popActScope(prevActQueue, prevActScopeDepth) {
-      prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
-      actScopeDepth = prevActScopeDepth;
-    }
-    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
-      var queue = ReactSharedInternals.actQueue;
-      if (queue !== null)
-        if (queue.length !== 0)
-          try {
-            flushActQueue(queue);
-            enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-            });
-            return;
-          } catch (error) {
-            ReactSharedInternals.thrownErrors.push(error);
+        modeBuffer = "";
+      }
+      function emitKeyword(keyword, scope) {
+        if (keyword === "")
+          return;
+        emitter.startScope(scope);
+        emitter.addText(keyword);
+        emitter.endScope();
+      }
+      function emitMultiClass(scope, match) {
+        let i = 1;
+        const max = match.length - 1;
+        while (i <= max) {
+          if (!scope._emit[i]) {
+            i++;
+            continue;
           }
-        else
-          ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
-    }
-    function flushActQueue(queue) {
-      if (!isFlushing) {
-        isFlushing = true;
-        var i = 0;
-        try {
-          for (;i < queue.length; i++) {
-            var callback = queue[i];
-            do {
-              ReactSharedInternals.didUsePromise = false;
-              var continuation = callback(false);
-              if (continuation !== null) {
-                if (ReactSharedInternals.didUsePromise) {
-                  queue[i] = callback;
-                  queue.splice(0, i);
-                  return;
-                }
-                callback = continuation;
-              } else
-                break;
-            } while (1);
+          const klass = language.classNameAliases[scope[i]] || scope[i];
+          const text = match[i];
+          if (klass) {
+            emitKeyword(text, klass);
+          } else {
+            modeBuffer = text;
+            processKeywords();
+            modeBuffer = "";
           }
-          queue.length = 0;
-        } catch (error) {
-          queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
-        } finally {
-          isFlushing = false;
+          i++;
         }
       }
-    }
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
-    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
-      isMounted: function() {
-        return false;
-      },
-      enqueueForceUpdate: function(publicInstance) {
-        warnNoop(publicInstance, "forceUpdate");
-      },
-      enqueueReplaceState: function(publicInstance) {
-        warnNoop(publicInstance, "replaceState");
-      },
-      enqueueSetState: function(publicInstance) {
-        warnNoop(publicInstance, "setState");
-      }
-    }, assign = Object.assign, emptyObject = {};
-    Object.freeze(emptyObject);
-    Component.prototype.isReactComponent = {};
-    Component.prototype.setState = function(partialState, callback) {
-      if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null)
-        throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
-      this.updater.enqueueSetState(this, partialState, callback, "setState");
-    };
-    Component.prototype.forceUpdate = function(callback) {
-      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
-    };
-    var deprecatedAPIs = {
-      isMounted: [
-        "isMounted",
-        "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
-      ],
-      replaceState: [
-        "replaceState",
-        "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
-      ]
-    };
-    for (fnName in deprecatedAPIs)
-      deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
-    ComponentDummy.prototype = Component.prototype;
-    deprecatedAPIs = PureComponent.prototype = new ComponentDummy;
-    deprecatedAPIs.constructor = PureComponent;
-    assign(deprecatedAPIs, Component.prototype);
-    deprecatedAPIs.isPureReactComponent = true;
-    var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = {
-      H: null,
-      A: null,
-      T: null,
-      S: null,
-      actQueue: null,
-      asyncTransitions: 0,
-      isBatchingLegacy: false,
-      didScheduleLegacyUpdate: false,
-      didUsePromise: false,
-      thrownErrors: [],
-      getCurrentStack: null,
-      recentlyCreatedOwnerStacks: 0
-    }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
-      return null;
-    };
-    deprecatedAPIs = {
-      react_stack_bottom_frame: function(callStackForError) {
-        return callStackForError();
+      function startNewMode(mode, match) {
+        if (mode.scope && typeof mode.scope === "string") {
+          emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+        }
+        if (mode.beginScope) {
+          if (mode.beginScope._wrap) {
+            emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+            modeBuffer = "";
+          } else if (mode.beginScope._multi) {
+            emitMultiClass(mode.beginScope, match);
+            modeBuffer = "";
+          }
+        }
+        top = Object.create(mode, { parent: { value: top } });
+        return top;
       }
-    };
-    var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
-    var didWarnAboutElementRef = {};
-    var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(deprecatedAPIs, UnknownOwner)();
-    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
-    var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = typeof reportError === "function" ? reportError : function(error) {
-      if (typeof window === "object" && typeof window.ErrorEvent === "function") {
-        var event = new window.ErrorEvent("error", {
-          bubbles: true,
-          cancelable: true,
-          message: typeof error === "object" && error !== null && typeof error.message === "string" ? String(error.message) : String(error),
-          error
-        });
-        if (!window.dispatchEvent(event))
-          return;
-      } else if (typeof process === "object" && typeof process.emit === "function") {
-        process.emit("uncaughtException", error);
-        return;
+      function endOfMode(mode, match, matchPlusRemainder) {
+        let matched = startsWith(mode.endRe, matchPlusRemainder);
+        if (matched) {
+          if (mode["on:end"]) {
+            const resp = new Response(mode);
+            mode["on:end"](match, resp);
+            if (resp.isMatchIgnored)
+              matched = false;
+          }
+          if (matched) {
+            while (mode.endsParent && mode.parent) {
+              mode = mode.parent;
+            }
+            return mode;
+          }
+        }
+        if (mode.endsWithParent) {
+          return endOfMode(mode.parent, match, matchPlusRemainder);
+        }
       }
-      console.error(error);
-    }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = typeof queueMicrotask === "function" ? function(callback) {
-      queueMicrotask(function() {
-        return queueMicrotask(callback);
-      });
-    } : enqueueTask;
-    deprecatedAPIs = Object.freeze({
-      __proto__: null,
-      c: function(size) {
-        return resolveDispatcher().useMemoCache(size);
+      function doIgnore(lexeme) {
+        if (top.matcher.regexIndex === 0) {
+          modeBuffer += lexeme[0];
+          return 1;
+        } else {
+          resumeScanAtSamePosition = true;
+          return 0;
+        }
       }
-    });
-    var fnName = {
-      map: mapChildren,
-      forEach: function(children, forEachFunc, forEachContext) {
-        mapChildren(children, function() {
-          forEachFunc.apply(this, arguments);
-        }, forEachContext);
-      },
-      count: function(children) {
-        var n = 0;
-        mapChildren(children, function() {
-          n++;
-        });
-        return n;
-      },
-      toArray: function(children) {
-        return mapChildren(children, function(child) {
-          return child;
-        }) || [];
-      },
-      only: function(children) {
-        if (!isValidElement(children))
-          throw Error("React.Children.only expected to receive a single React element child.");
-        return children;
+      function doBeginMatch(match) {
+        const lexeme = match[0];
+        const newMode = match.rule;
+        const resp = new Response(newMode);
+        const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+        for (const cb of beforeCallbacks) {
+          if (!cb)
+            continue;
+          cb(match, resp);
+          if (resp.isMatchIgnored)
+            return doIgnore(lexeme);
+        }
+        if (newMode.skip) {
+          modeBuffer += lexeme;
+        } else {
+          if (newMode.excludeBegin) {
+            modeBuffer += lexeme;
+          }
+          processBuffer();
+          if (!newMode.returnBegin && !newMode.excludeBegin) {
+            modeBuffer = lexeme;
+          }
+        }
+        startNewMode(newMode, match);
+        return newMode.returnBegin ? 0 : lexeme.length;
       }
-    };
-    exports.Activity = REACT_ACTIVITY_TYPE;
-    exports.Children = fnName;
-    exports.Component = Component;
-    exports.Fragment = REACT_FRAGMENT_TYPE;
-    exports.Profiler = REACT_PROFILER_TYPE;
-    exports.PureComponent = PureComponent;
-    exports.StrictMode = REACT_STRICT_MODE_TYPE;
-    exports.Suspense = REACT_SUSPENSE_TYPE;
-    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
-    exports.__COMPILER_RUNTIME = deprecatedAPIs;
-    exports.act = function(callback) {
-      var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
-      actScopeDepth++;
-      var queue = ReactSharedInternals.actQueue = prevActQueue !== null ? prevActQueue : [], didAwaitActCall = false;
-      try {
-        var result = callback();
-      } catch (error) {
-        ReactSharedInternals.thrownErrors.push(error);
-      }
-      if (0 < ReactSharedInternals.thrownErrors.length)
-        throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
-      if (result !== null && typeof result === "object" && typeof result.then === "function") {
-        var thenable = result;
-        queueSeveralMicrotasks(function() {
-          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
-        });
-        return {
-          then: function(resolve, reject) {
-            didAwaitActCall = true;
-            thenable.then(function(returnValue) {
-              popActScope(prevActQueue, prevActScopeDepth);
-              if (prevActScopeDepth === 0) {
-                try {
-                  flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-                  });
-                } catch (error$0) {
-                  ReactSharedInternals.thrownErrors.push(error$0);
-                }
-                if (0 < ReactSharedInternals.thrownErrors.length) {
-                  var _thrownError = aggregateErrors(ReactSharedInternals.thrownErrors);
-                  ReactSharedInternals.thrownErrors.length = 0;
-                  reject(_thrownError);
-                }
-              } else
-                resolve(returnValue);
-            }, function(error) {
-              popActScope(prevActQueue, prevActScopeDepth);
-              0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
-            });
+      function doEndMatch(match) {
+        const lexeme = match[0];
+        const matchPlusRemainder = codeToHighlight.substring(match.index);
+        const endMode = endOfMode(top, match, matchPlusRemainder);
+        if (!endMode) {
+          return NO_MATCH;
+        }
+        const origin = top;
+        if (top.endScope && top.endScope._wrap) {
+          processBuffer();
+          emitKeyword(lexeme, top.endScope._wrap);
+        } else if (top.endScope && top.endScope._multi) {
+          processBuffer();
+          emitMultiClass(top.endScope, match);
+        } else if (origin.skip) {
+          modeBuffer += lexeme;
+        } else {
+          if (!(origin.returnEnd || origin.excludeEnd)) {
+            modeBuffer += lexeme;
           }
-        };
+          processBuffer();
+          if (origin.excludeEnd) {
+            modeBuffer = lexeme;
+          }
+        }
+        do {
+          if (top.scope) {
+            emitter.closeNode();
+          }
+          if (!top.skip && !top.subLanguage) {
+            relevance += top.relevance;
+          }
+          top = top.parent;
+        } while (top !== endMode.parent);
+        if (endMode.starts) {
+          startNewMode(endMode.starts, match);
+        }
+        return origin.returnEnd ? 0 : lexeme.length;
       }
-      var returnValue$jscomp$0 = result;
-      popActScope(prevActQueue, prevActScopeDepth);
-      prevActScopeDepth === 0 && (flushActQueue(queue), queue.length !== 0 && queueSeveralMicrotasks(function() {
-        didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"));
-      }), ReactSharedInternals.actQueue = null);
-      if (0 < ReactSharedInternals.thrownErrors.length)
-        throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
-      return {
-        then: function(resolve, reject) {
-          didAwaitActCall = true;
-          prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
-          })) : resolve(returnValue$jscomp$0);
+      function processContinuations() {
+        const list = [];
+        for (let current = top;current !== language; current = current.parent) {
+          if (current.scope) {
+            list.unshift(current.scope);
+          }
         }
-      };
-    };
-    exports.cache = function(fn) {
-      return function() {
-        return fn.apply(null, arguments);
-      };
-    };
-    exports.cacheSignal = function() {
-      return null;
-    };
-    exports.captureOwnerStack = function() {
-      var getCurrentStack = ReactSharedInternals.getCurrentStack;
-      return getCurrentStack === null ? null : getCurrentStack();
-    };
-    exports.cloneElement = function(element, config, children) {
-      if (element === null || element === undefined)
-        throw Error("The argument must be a React element, but you passed " + element + ".");
-      var props = assign({}, element.props), key = element.key, owner = element._owner;
-      if (config != null) {
-        var JSCompiler_inline_result;
-        a: {
-          if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(config, "ref").get) && JSCompiler_inline_result.isReactWarning) {
-            JSCompiler_inline_result = false;
-            break a;
+        list.forEach((item) => emitter.openNode(item));
+      }
+      let lastMatch = {};
+      function processLexeme(textBeforeMatch, match) {
+        const lexeme = match && match[0];
+        modeBuffer += textBeforeMatch;
+        if (lexeme == null) {
+          processBuffer();
+          return 0;
+        }
+        if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+          modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+          if (!SAFE_MODE) {
+            const err = new Error(`0 width match regex (${languageName})`);
+            err.languageName = languageName;
+            err.badRule = lastMatch.rule;
+            throw err;
           }
-          JSCompiler_inline_result = config.ref !== undefined;
+          return 1;
+        }
+        lastMatch = match;
+        if (match.type === "begin") {
+          return doBeginMatch(match);
+        } else if (match.type === "illegal" && !ignoreIllegals) {
+          const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "<unnamed>") + '"');
+          err.mode = top;
+          throw err;
+        } else if (match.type === "end") {
+          const processed = doEndMatch(match);
+          if (processed !== NO_MATCH) {
+            return processed;
+          }
+        }
+        if (match.type === "illegal" && lexeme === "") {
+          modeBuffer += `
+`;
+          return 1;
+        }
+        if (iterations > 1e5 && iterations > match.index * 3) {
+          const err = new Error("potential infinite loop, way more iterations than matches");
+          throw err;
+        }
+        modeBuffer += lexeme;
+        return lexeme.length;
+      }
+      const language = getLanguage(languageName);
+      if (!language) {
+        error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+        throw new Error('Unknown language: "' + languageName + '"');
+      }
+      const md = compileLanguage(language);
+      let result = "";
+      let top = continuation || md;
+      const continuations = {};
+      const emitter = new options.__emitter(options);
+      processContinuations();
+      let modeBuffer = "";
+      let relevance = 0;
+      let index = 0;
+      let iterations = 0;
+      let resumeScanAtSamePosition = false;
+      try {
+        if (!language.__emitTokens) {
+          top.matcher.considerAll();
+          for (;; ) {
+            iterations++;
+            if (resumeScanAtSamePosition) {
+              resumeScanAtSamePosition = false;
+            } else {
+              top.matcher.considerAll();
+            }
+            top.matcher.lastIndex = index;
+            const match = top.matcher.exec(codeToHighlight);
+            if (!match)
+              break;
+            const beforeMatch = codeToHighlight.substring(index, match.index);
+            const processedCount = processLexeme(beforeMatch, match);
+            index = match.index + processedCount;
+          }
+          processLexeme(codeToHighlight.substring(index));
+        } else {
+          language.__emitTokens(codeToHighlight, emitter);
+        }
+        emitter.finalize();
+        result = emitter.toHTML();
+        return {
+          language: languageName,
+          value: result,
+          relevance,
+          illegal: false,
+          _emitter: emitter,
+          _top: top
+        };
+      } catch (err) {
+        if (err.message && err.message.includes("Illegal")) {
+          return {
+            language: languageName,
+            value: escape(codeToHighlight),
+            illegal: true,
+            relevance: 0,
+            _illegalBy: {
+              message: err.message,
+              index,
+              context: codeToHighlight.slice(index - 100, index + 100),
+              mode: err.mode,
+              resultSoFar: result
+            },
+            _emitter: emitter
+          };
+        } else if (SAFE_MODE) {
+          return {
+            language: languageName,
+            value: escape(codeToHighlight),
+            illegal: false,
+            relevance: 0,
+            errorRaised: err,
+            _emitter: emitter,
+            _top: top
+          };
+        } else {
+          throw err;
         }
-        JSCompiler_inline_result && (owner = getOwner());
-        hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
-        for (propName in config)
-          !hasOwnProperty.call(config, propName) || propName === "key" || propName === "__self" || propName === "__source" || propName === "ref" && config.ref === undefined || (props[propName] = config[propName]);
-      }
-      var propName = arguments.length - 2;
-      if (propName === 1)
-        props.children = children;
-      else if (1 < propName) {
-        JSCompiler_inline_result = Array(propName);
-        for (var i = 0;i < propName; i++)
-          JSCompiler_inline_result[i] = arguments[i + 2];
-        props.children = JSCompiler_inline_result;
-      }
-      props = ReactElement(element.type, key, props, owner, element._debugStack, element._debugTask);
-      for (key = 2;key < arguments.length; key++)
-        validateChildKeys(arguments[key]);
-      return props;
-    };
-    exports.createContext = function(defaultValue) {
-      defaultValue = {
-        $$typeof: REACT_CONTEXT_TYPE,
-        _currentValue: defaultValue,
-        _currentValue2: defaultValue,
-        _threadCount: 0,
-        Provider: null,
-        Consumer: null
-      };
-      defaultValue.Provider = defaultValue;
-      defaultValue.Consumer = {
-        $$typeof: REACT_CONSUMER_TYPE,
-        _context: defaultValue
+      }
+    }
+    function justTextHighlightResult(code) {
+      const result = {
+        value: escape(code),
+        illegal: false,
+        relevance: 0,
+        _top: PLAINTEXT_LANGUAGE,
+        _emitter: new options.__emitter(options)
       };
-      defaultValue._currentRenderer = null;
-      defaultValue._currentRenderer2 = null;
-      return defaultValue;
-    };
-    exports.createElement = function(type, config, children) {
-      for (var i = 2;i < arguments.length; i++)
-        validateChildKeys(arguments[i]);
-      i = {};
-      var key = null;
-      if (config != null)
-        for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn("Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform")), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
-          hasOwnProperty.call(config, propName) && propName !== "key" && propName !== "__self" && propName !== "__source" && (i[propName] = config[propName]);
-      var childrenLength = arguments.length - 2;
-      if (childrenLength === 1)
-        i.children = children;
-      else if (1 < childrenLength) {
-        for (var childArray = Array(childrenLength), _i = 0;_i < childrenLength; _i++)
-          childArray[_i] = arguments[_i + 2];
-        Object.freeze && Object.freeze(childArray);
-        i.children = childArray;
-      }
-      if (type && type.defaultProps)
-        for (propName in childrenLength = type.defaultProps, childrenLength)
-          i[propName] === undefined && (i[propName] = childrenLength[propName]);
-      key && defineKeyPropWarningGetter(i, typeof type === "function" ? type.displayName || type.name || "Unknown" : type);
-      var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
-      return ReactElement(type, key, i, getOwner(), propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack, propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask);
-    };
-    exports.createRef = function() {
-      var refObject = { current: null };
-      Object.seal(refObject);
-      return refObject;
-    };
-    exports.forwardRef = function(render) {
-      render != null && render.$$typeof === REACT_MEMO_TYPE ? console.error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof render !== "function" ? console.error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render) : render.length !== 0 && render.length !== 2 && console.error("forwardRef render functions accept exactly two parameters: props and ref. %s", render.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined.");
-      render != null && render.defaultProps != null && console.error("forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?");
-      var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
-      Object.defineProperty(elementType, "displayName", {
-        enumerable: false,
-        configurable: true,
-        get: function() {
-          return ownName;
-        },
-        set: function(name) {
-          ownName = name;
-          render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+      result._emitter.addText(code);
+      return result;
+    }
+    function highlightAuto(code, languageSubset) {
+      languageSubset = languageSubset || options.languages || Object.keys(languages);
+      const plaintext = justTextHighlightResult(code);
+      const results = languageSubset.filter(getLanguage).filter(autoDetection).map((name) => _highlight(name, code, false));
+      results.unshift(plaintext);
+      const sorted = results.sort((a, b) => {
+        if (a.relevance !== b.relevance)
+          return b.relevance - a.relevance;
+        if (a.language && b.language) {
+          if (getLanguage(a.language).supersetOf === b.language) {
+            return 1;
+          } else if (getLanguage(b.language).supersetOf === a.language) {
+            return -1;
+          }
         }
+        return 0;
       });
-      return elementType;
-    };
-    exports.isValidElement = isValidElement;
-    exports.lazy = function(ctor) {
-      ctor = { _status: -1, _result: ctor };
-      var lazyType = {
-        $$typeof: REACT_LAZY_TYPE,
-        _payload: ctor,
-        _init: lazyInitializer
-      }, ioInfo = {
-        name: "lazy",
-        start: -1,
-        end: -1,
-        value: null,
-        owner: null,
-        debugStack: Error("react-stack-top-frame"),
-        debugTask: console.createTask ? console.createTask("lazy()") : null
+      const [best, secondBest] = sorted;
+      const result = best;
+      result.secondBest = secondBest;
+      return result;
+    }
+    function updateClassName(element, currentLang, resultLang) {
+      const language = currentLang && aliases[currentLang] || resultLang;
+      element.classList.add("hljs");
+      element.classList.add(`language-${language}`);
+    }
+    function highlightElement(element) {
+      let node = null;
+      const language = blockLanguage(element);
+      if (shouldNotHighlight(language))
+        return;
+      fire("before:highlightElement", { el: element, language });
+      if (element.dataset.highlighted) {
+        console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+        return;
+      }
+      if (element.children.length > 0) {
+        if (!options.ignoreUnescapedHTML) {
+          console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+          console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+          console.warn("The element with unescaped HTML:");
+          console.warn(element);
+        }
+        if (options.throwUnescapedHTML) {
+          const err = new HTMLInjectionError("One of your code blocks includes unescaped HTML.", element.innerHTML);
+          throw err;
+        }
+      }
+      node = element;
+      const text = node.textContent;
+      const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+      element.innerHTML = result.value;
+      element.dataset.highlighted = "yes";
+      updateClassName(element, language, result.language);
+      element.result = {
+        language: result.language,
+        re: result.relevance,
+        relevance: result.relevance
       };
-      ctor._ioInfo = ioInfo;
-      lazyType._debugInfo = [{ awaited: ioInfo }];
-      return lazyType;
+      if (result.secondBest) {
+        element.secondBest = {
+          language: result.secondBest.language,
+          relevance: result.secondBest.relevance
+        };
+      }
+      fire("after:highlightElement", { el: element, result, text });
+    }
+    function configure(userOptions) {
+      options = inherit(options, userOptions);
+    }
+    const initHighlighting = () => {
+      highlightAll();
+      deprecated("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
     };
-    exports.memo = function(type, compare) {
-      type == null && console.error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
-      compare = {
-        $$typeof: REACT_MEMO_TYPE,
-        type,
-        compare: compare === undefined ? null : compare
-      };
-      var ownName;
-      Object.defineProperty(compare, "displayName", {
-        enumerable: false,
-        configurable: true,
-        get: function() {
-          return ownName;
-        },
-        set: function(name) {
-          ownName = name;
-          type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+    function initHighlightingOnLoad() {
+      highlightAll();
+      deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+    }
+    let wantsHighlight = false;
+    function highlightAll() {
+      function boot() {
+        highlightAll();
+      }
+      if (document.readyState === "loading") {
+        if (!wantsHighlight) {
+          window.addEventListener("DOMContentLoaded", boot, false);
         }
-      });
-      return compare;
-    };
-    exports.startTransition = function(scope) {
-      var prevTransition = ReactSharedInternals.T, currentTransition = {};
-      currentTransition._updatedFibers = new Set;
-      ReactSharedInternals.T = currentTransition;
+        wantsHighlight = true;
+        return;
+      }
+      const blocks = document.querySelectorAll(options.cssSelector);
+      blocks.forEach(highlightElement);
+    }
+    function registerLanguage(languageName, languageDefinition) {
+      let lang = null;
       try {
-        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
-        onStartTransitionFinish !== null && onStartTransitionFinish(currentTransition, returnValue);
-        typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function" && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
-      } catch (error) {
-        reportGlobalError(error);
-      } finally {
-        prevTransition === null && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.")), prevTransition !== null && currentTransition.types !== null && (prevTransition.types !== null && prevTransition.types !== currentTransition.types && console.error("We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+        lang = languageDefinition(hljs);
+      } catch (error$1) {
+        error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+        if (!SAFE_MODE) {
+          throw error$1;
+        } else {
+          error(error$1);
+        }
+        lang = PLAINTEXT_LANGUAGE;
       }
+      if (!lang.name)
+        lang.name = languageName;
+      languages[languageName] = lang;
+      lang.rawDefinition = languageDefinition.bind(null, hljs);
+      if (lang.aliases) {
+        registerAliases(lang.aliases, { languageName });
+      }
+    }
+    function unregisterLanguage(languageName) {
+      delete languages[languageName];
+      for (const alias of Object.keys(aliases)) {
+        if (aliases[alias] === languageName) {
+          delete aliases[alias];
+        }
+      }
+    }
+    function listLanguages() {
+      return Object.keys(languages);
+    }
+    function getLanguage(name) {
+      name = (name || "").toLowerCase();
+      return languages[name] || languages[aliases[name]];
+    }
+    function registerAliases(aliasList, { languageName }) {
+      if (typeof aliasList === "string") {
+        aliasList = [aliasList];
+      }
+      aliasList.forEach((alias) => {
+        aliases[alias.toLowerCase()] = languageName;
+      });
+    }
+    function autoDetection(name) {
+      const lang = getLanguage(name);
+      return lang && !lang.disableAutodetect;
+    }
+    function upgradePluginAPI(plugin) {
+      if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+        plugin["before:highlightElement"] = (data) => {
+          plugin["before:highlightBlock"](Object.assign({ block: data.el }, data));
+        };
+      }
+      if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+        plugin["after:highlightElement"] = (data) => {
+          plugin["after:highlightBlock"](Object.assign({ block: data.el }, data));
+        };
+      }
+    }
+    function addPlugin(plugin) {
+      upgradePluginAPI(plugin);
+      plugins.push(plugin);
+    }
+    function removePlugin(plugin) {
+      const index = plugins.indexOf(plugin);
+      if (index !== -1) {
+        plugins.splice(index, 1);
+      }
+    }
+    function fire(event, args) {
+      const cb = event;
+      plugins.forEach(function(plugin) {
+        if (plugin[cb]) {
+          plugin[cb](args);
+        }
+      });
+    }
+    function deprecateHighlightBlock(el) {
+      deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+      deprecated("10.7.0", "Please use highlightElement now.");
+      return highlightElement(el);
+    }
+    Object.assign(hljs, {
+      highlight: highlight2,
+      highlightAuto,
+      highlightAll,
+      highlightElement,
+      highlightBlock: deprecateHighlightBlock,
+      configure,
+      initHighlighting,
+      initHighlightingOnLoad,
+      registerLanguage,
+      unregisterLanguage,
+      listLanguages,
+      getLanguage,
+      registerAliases,
+      autoDetection,
+      inherit,
+      addPlugin,
+      removePlugin
+    });
+    hljs.debugMode = function() {
+      SAFE_MODE = false;
     };
-    exports.unstable_useCacheRefresh = function() {
-      return resolveDispatcher().useCacheRefresh();
-    };
-    exports.use = function(usable) {
-      return resolveDispatcher().use(usable);
-    };
-    exports.useActionState = function(action, initialState, permalink) {
-      return resolveDispatcher().useActionState(action, initialState, permalink);
-    };
-    exports.useCallback = function(callback, deps) {
-      return resolveDispatcher().useCallback(callback, deps);
-    };
-    exports.useContext = function(Context) {
-      var dispatcher = resolveDispatcher();
-      Context.$$typeof === REACT_CONSUMER_TYPE && console.error("Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?");
-      return dispatcher.useContext(Context);
-    };
-    exports.useDebugValue = function(value, formatterFn) {
-      return resolveDispatcher().useDebugValue(value, formatterFn);
-    };
-    exports.useDeferredValue = function(value, initialValue) {
-      return resolveDispatcher().useDeferredValue(value, initialValue);
-    };
-    exports.useEffect = function(create, deps) {
-      create == null && console.warn("React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useEffect(create, deps);
-    };
-    exports.useEffectEvent = function(callback) {
-      return resolveDispatcher().useEffectEvent(callback);
-    };
-    exports.useId = function() {
-      return resolveDispatcher().useId();
-    };
-    exports.useImperativeHandle = function(ref, create, deps) {
-      return resolveDispatcher().useImperativeHandle(ref, create, deps);
-    };
-    exports.useInsertionEffect = function(create, deps) {
-      create == null && console.warn("React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useInsertionEffect(create, deps);
-    };
-    exports.useLayoutEffect = function(create, deps) {
-      create == null && console.warn("React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?");
-      return resolveDispatcher().useLayoutEffect(create, deps);
-    };
-    exports.useMemo = function(create, deps) {
-      return resolveDispatcher().useMemo(create, deps);
-    };
-    exports.useOptimistic = function(passthrough, reducer) {
-      return resolveDispatcher().useOptimistic(passthrough, reducer);
-    };
-    exports.useReducer = function(reducer, initialArg, init) {
-      return resolveDispatcher().useReducer(reducer, initialArg, init);
-    };
-    exports.useRef = function(initialValue) {
-      return resolveDispatcher().useRef(initialValue);
-    };
-    exports.useState = function(initialState) {
-      return resolveDispatcher().useState(initialState);
-    };
-    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
-      return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    hljs.safeMode = function() {
+      SAFE_MODE = true;
     };
-    exports.useTransition = function() {
-      return resolveDispatcher().useTransition();
+    hljs.versionString = version;
+    hljs.regex = {
+      concat,
+      lookahead,
+      either,
+      optional,
+      anyNumberOfTimes
     };
-    exports.version = "19.2.7";
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
-  })();
-});
-
-// ../../node_modules/.bun/react@19.2.7/node_modules/react/index.js
-var require_react = __commonJS((exports, module) => {
-  var react_development = __toESM(require_react_development());
-  if (false) {} else {
-    module.exports = react_development;
-  }
+    for (const key in MODES) {
+      if (typeof MODES[key] === "object") {
+        deepFreeze(MODES[key]);
+      }
+    }
+    Object.assign(hljs, MODES);
+    return hljs;
+  };
+  var highlight = HLJS({});
+  highlight.newInstance = () => HLJS({});
+  module.exports = highlight;
+  highlight.HighlightJS = highlight;
+  highlight.default = highlight;
 });
 
 // src/labels.ts
@@ -1084,6 +1674,9 @@ function shouldShowChatCommandMenu(value, surface, labels) {
   }
   return filterChatCommands(value, surface, labels).length > 0;
 }
+function completionForChatCommand(command) {
+  return `${command.usage} `;
+}
 function listChatCommands(surface, labels) {
   const resolved = resolveLabels(labels);
   return CHAT_COMMANDS.filter((command) => !surface || command.surfaces.includes(surface)).map(({ name, description }) => ({
@@ -1138,7 +1731,7 @@ async function runAssistantChatCommand(input, deps) {
 var REQUEST_CHOICES_TOOL = "request_choices";
 var CHOICES_TOOL = {
   name: REQUEST_CHOICES_TOOL,
-  description: "Present options when multiple valid paths exist and you need the user to choose before continuing. Supports single-select and multi-select.",
+  description: "Block and wait for the user to pick one action path before you execute. Never use to list, display, summarize, or format information — write that in your text reply instead. Never for opening tabs or navigation. At most once per user request.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1239,7 +1832,7 @@ function parseChoicesArgs(args) {
 var REQUEST_CONFIRMATION_TOOL = "request_confirmation";
 var CONFIRMATION_TOOL = {
   name: REQUEST_CONFIRMATION_TOOL,
-  description: "Ask the user to confirm before proceeding with an important or irreversible action. Execution pauses until the user confirms or cancels.",
+  description: "Ask the user to confirm ONLY before destructive or irreversible writes (delete, reset, import overwrite, bulk mutations). Never use for navigation, opening tabs, viewing data, or read-only operations. At most once per user request.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1414,6 +2007,80 @@ async function executeChatInteractiveTool(name, args, callId, signal) {
 function shouldTerminateTurnAfterTool(name) {
   return isPostResponseChatTool(name);
 }
+// src/core/interactive-tools/gate.ts
+var NAMESPACED_TOOL_PATTERN = /^@[^/]+\/.+/;
+function createInteractiveAgentGate() {
+  return {
+    confirmationCalls: 0,
+    choicesCalls: 0,
+    registryToolCalls: 0
+  };
+}
+function isDisplayChoicesArgs(args) {
+  if (!Array.isArray(args.options) || args.options.length < 2)
+    return false;
+  return args.options.every((entry) => {
+    if (!entry || typeof entry !== "object")
+      return false;
+    const option = entry;
+    const id = String(option.id ?? "").trim();
+    const label = String(option.label ?? "").trim();
+    return NAMESPACED_TOOL_PATTERN.test(id) || NAMESPACED_TOOL_PATTERN.test(label);
+  });
+}
+function shouldAutoResolveInteractiveTool(gate, toolName, args) {
+  if (toolName === REQUEST_CHOICES_TOOL && args && isDisplayChoicesArgs(args)) {
+    return true;
+  }
+  if (gate.registryToolCalls > 0)
+    return false;
+  if (toolName === REQUEST_CONFIRMATION_TOOL && gate.confirmationCalls > 0) {
+    return true;
+  }
+  if (toolName === REQUEST_CHOICES_TOOL && gate.choicesCalls > 0) {
+    return true;
+  }
+  return false;
+}
+function recordInteractiveToolCall(gate, toolName) {
+  if (toolName === REQUEST_CONFIRMATION_TOOL) {
+    gate.confirmationCalls += 1;
+    return;
+  }
+  if (toolName === REQUEST_CHOICES_TOOL) {
+    gate.choicesCalls += 1;
+  }
+}
+function recordRegistryToolCall(gate) {
+  gate.registryToolCalls += 1;
+}
+function shouldInjectActionNudge(gate) {
+  return gate.confirmationCalls + gate.choicesCalls >= 2 && gate.registryToolCalls === 0;
+}
+function actionToolNudgeMessage() {
+  return "The user already responded to your prompts. Fulfill their request now " + "with an action tool. Do not call request_confirmation or request_choices again.";
+}
+function autoResolvedInteractiveResult(toolName, args) {
+  if (toolName === REQUEST_CHOICES_TOOL && args && isDisplayChoicesArgs(args)) {
+    return JSON.stringify({
+      selected: [],
+      autoResolved: true,
+      message: "Do not present items as a choice menu. Reply in your message with a markdown table or numbered list instead."
+    });
+  }
+  if (toolName === REQUEST_CONFIRMATION_TOOL) {
+    return JSON.stringify({
+      confirmed: true,
+      autoResolved: true,
+      message: "Confirmation was already collected. Call the action tool immediately."
+    });
+  }
+  return JSON.stringify({
+    selected: [],
+    autoResolved: true,
+    message: "A choice was already submitted. Call the action tool immediately."
+  });
+}
 // src/core/chat-history.ts
 var DEFAULT_HISTORY_KEY = "assistant-chat-history";
 var DEFAULT_MAX_STORED = 100;
@@ -1486,6 +2153,283 @@ function createChatHistoryHelpers(options) {
   }
   return { getStored, persist, clear, loadInitial };
 }
+// ../../node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/es/core.js
+var import_core = __toESM(require_core(), 1);
+var core_default = import_core.default;
+
+// ../../node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/es/languages/json.js
+function json(hljs) {
+  const ATTRIBUTE = {
+    className: "attr",
+    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
+    relevance: 1.01
+  };
+  const PUNCTUATION = {
+    match: /[{}[\],:]/,
+    className: "punctuation",
+    relevance: 0
+  };
+  const LITERALS = [
+    "true",
+    "false",
+    "null"
+  ];
+  const LITERALS_MODE = {
+    scope: "literal",
+    beginKeywords: LITERALS.join(" ")
+  };
+  return {
+    name: "JSON",
+    aliases: ["jsonc"],
+    keywords: {
+      literal: LITERALS
+    },
+    contains: [
+      ATTRIBUTE,
+      PUNCTUATION,
+      hljs.QUOTE_STRING_MODE,
+      LITERALS_MODE,
+      hljs.C_NUMBER_MODE,
+      hljs.C_LINE_COMMENT_MODE,
+      hljs.C_BLOCK_COMMENT_MODE
+    ],
+    illegal: "\\S"
+  };
+}
+
+// ../../node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/es/languages/markdown.js
+function markdown(hljs) {
+  const regex = hljs.regex;
+  const INLINE_HTML = {
+    begin: /<\/?[A-Za-z_]/,
+    end: ">",
+    subLanguage: "xml",
+    relevance: 0
+  };
+  const HORIZONTAL_RULE = {
+    begin: "^[-\\*]{3,}",
+    end: "$"
+  };
+  const CODE = {
+    className: "code",
+    variants: [
+      { begin: "(`{3,})[^`](.|\\n)*?\\1`*[ ]*" },
+      { begin: "(~{3,})[^~](.|\\n)*?\\1~*[ ]*" },
+      {
+        begin: "```",
+        end: "```+[ ]*$"
+      },
+      {
+        begin: "~~~",
+        end: "~~~+[ ]*$"
+      },
+      { begin: "`.+?`" },
+      {
+        begin: "(?=^( {4}|\\t))",
+        contains: [
+          {
+            begin: "^( {4}|\\t)",
+            end: "(\\n)$"
+          }
+        ],
+        relevance: 0
+      }
+    ]
+  };
+  const LIST = {
+    className: "bullet",
+    begin: "^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
+    end: "\\s+",
+    excludeEnd: true
+  };
+  const LINK_REFERENCE = {
+    begin: /^\[[^\n]+\]:/,
+    returnBegin: true,
+    contains: [
+      {
+        className: "symbol",
+        begin: /\[/,
+        end: /\]/,
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: "link",
+        begin: /:\s*/,
+        end: /$/,
+        excludeBegin: true
+      }
+    ]
+  };
+  const URL_SCHEME = /[A-Za-z][A-Za-z0-9+.-]*/;
+  const LINK = {
+    variants: [
+      {
+        begin: /\[.+?\]\[.*?\]/,
+        relevance: 0
+      },
+      {
+        begin: /\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+        relevance: 2
+      },
+      {
+        begin: regex.concat(/\[.+?\]\(/, URL_SCHEME, /:\/\/.*?\)/),
+        relevance: 2
+      },
+      {
+        begin: /\[.+?\]\([./?&#].*?\)/,
+        relevance: 1
+      },
+      {
+        begin: /\[.*?\]\(.*?\)/,
+        relevance: 0
+      }
+    ],
+    returnBegin: true,
+    contains: [
+      {
+        match: /\[(?=\])/
+      },
+      {
+        className: "string",
+        relevance: 0,
+        begin: "\\[",
+        end: "\\]",
+        excludeBegin: true,
+        returnEnd: true
+      },
+      {
+        className: "link",
+        relevance: 0,
+        begin: "\\]\\(",
+        end: "\\)",
+        excludeBegin: true,
+        excludeEnd: true
+      },
+      {
+        className: "symbol",
+        relevance: 0,
+        begin: "\\]\\[",
+        end: "\\]",
+        excludeBegin: true,
+        excludeEnd: true
+      }
+    ]
+  };
+  const BOLD = {
+    className: "strong",
+    contains: [],
+    variants: [
+      {
+        begin: /_{2}(?!\s)/,
+        end: /_{2}/
+      },
+      {
+        begin: /\*{2}(?!\s)/,
+        end: /\*{2}/
+      }
+    ]
+  };
+  const ITALIC = {
+    className: "emphasis",
+    contains: [],
+    variants: [
+      {
+        begin: /\*(?![*\s])/,
+        end: /\*/
+      },
+      {
+        begin: /_(?![_\s])/,
+        end: /_/,
+        relevance: 0
+      }
+    ]
+  };
+  const BOLD_WITHOUT_ITALIC = hljs.inherit(BOLD, { contains: [] });
+  const ITALIC_WITHOUT_BOLD = hljs.inherit(ITALIC, { contains: [] });
+  BOLD.contains.push(ITALIC_WITHOUT_BOLD);
+  ITALIC.contains.push(BOLD_WITHOUT_ITALIC);
+  let CONTAINABLE = [
+    INLINE_HTML,
+    LINK
+  ];
+  [
+    BOLD,
+    ITALIC,
+    BOLD_WITHOUT_ITALIC,
+    ITALIC_WITHOUT_BOLD
+  ].forEach((m) => {
+    m.contains = m.contains.concat(CONTAINABLE);
+  });
+  CONTAINABLE = CONTAINABLE.concat(BOLD, ITALIC);
+  const HEADER = {
+    className: "section",
+    variants: [
+      {
+        begin: "^#{1,6}",
+        end: "$",
+        contains: CONTAINABLE
+      },
+      {
+        begin: "(?=^.+?\\n[=-]{2,}$)",
+        contains: [
+          { begin: "^[=-]*$" },
+          {
+            begin: "^",
+            end: "\\n",
+            contains: CONTAINABLE
+          }
+        ]
+      }
+    ]
+  };
+  const BLOCKQUOTE = {
+    className: "quote",
+    begin: "^>\\s+",
+    contains: CONTAINABLE,
+    end: "$"
+  };
+  const ENTITY = {
+    scope: "literal",
+    match: /&([a-zA-Z0-9]+|#[0-9]{1,7}|#[Xx][0-9a-fA-F]{1,6});/
+  };
+  return {
+    name: "Markdown",
+    aliases: [
+      "md",
+      "mkdown",
+      "mkd"
+    ],
+    contains: [
+      HEADER,
+      INLINE_HTML,
+      LIST,
+      BOLD,
+      ITALIC,
+      BLOCKQUOTE,
+      CODE,
+      HORIZONTAL_RULE,
+      LINK,
+      LINK_REFERENCE,
+      ENTITY
+    ]
+  };
+}
+
+// src/core/code-highlight.ts
+core_default.registerLanguage("json", json);
+core_default.registerLanguage("markdown", markdown);
+function normalizeCodeLineEndings(code) {
+  return code.replace(/\r\n?/g, `
+`);
+}
+function highlightCode(code, language) {
+  const source = normalizeCodeLineEndings(code);
+  if (language && core_default.getLanguage(language)) {
+    return core_default.highlight(source, { language, ignoreIllegals: true }).value;
+  }
+  return core_default.highlightAuto(source).value;
+}
 // ../../node_modules/.bun/zustand@5.0.14+93dbe784b8baa420/node_modules/zustand/esm/vanilla.mjs
 var createStoreImpl = (createState) => {
   let state;
@@ -1511,11 +2455,11 @@ var createStoreImpl = (createState) => {
 var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
 
 // ../../node_modules/.bun/zustand@5.0.14+93dbe784b8baa420/node_modules/zustand/esm/react.mjs
-var import_react = __toESM(require_react(), 1);
+import React from "react";
 var identity = (arg) => arg;
 function useStore(api, selector = identity) {
-  const slice = import_react.default.useSyncExternalStore(api.subscribe, import_react.default.useCallback(() => selector(api.getState()), [api, selector]), import_react.default.useCallback(() => selector(api.getInitialState()), [api, selector]));
-  import_react.default.useDebugValue(slice);
+  const slice = React.useSyncExternalStore(api.subscribe, React.useCallback(() => selector(api.getState()), [api, selector]), React.useCallback(() => selector(api.getInitialState()), [api, selector]));
+  React.useDebugValue(slice);
   return slice;
 }
 var createImpl = (createState) => {
@@ -1654,7 +2598,20 @@ var DISABLED_SETTINGS = {
   apiKey: null,
   model: DEFAULT_LLM_MODEL
 };
+var GLOBAL_RESOLVER_KEY = Symbol.for("@4djs/assistant/llm-resolver");
 var resolveSettings = null;
+function getGlobalResolver() {
+  return globalThis[GLOBAL_RESOLVER_KEY] ?? null;
+}
+function setSharedResolver(resolver) {
+  resolveSettings = resolver;
+  const globalRecord = globalThis;
+  if (resolver) {
+    globalRecord[GLOBAL_RESOLVER_KEY] = resolver;
+  } else {
+    delete globalRecord[GLOBAL_RESOLVER_KEY];
+  }
+}
 function normalizeSettings(input) {
   return {
     enabled: input.enabled,
@@ -1667,19 +2624,20 @@ function normalizeSettings(input) {
 }
 function configureAssistantLlm(config) {
   if (typeof config === "function") {
-    resolveSettings = async () => normalizeSettings(await config());
+    setSharedResolver(async () => normalizeSettings(await config()));
     return;
   }
   const settings = normalizeSettings(config);
-  resolveSettings = async () => settings;
+  setSharedResolver(async () => settings);
 }
 async function resolveAssistantLlmSettings() {
-  if (!resolveSettings)
+  const resolver = resolveSettings ?? getGlobalResolver();
+  if (!resolver)
     return DISABLED_SETTINGS;
-  return resolveSettings();
+  return resolver();
 }
 function resetAssistantLlm() {
-  resolveSettings = null;
+  setSharedResolver(null);
 }
 async function testLlmConnection(settings) {
   if (!settings.apiKey?.trim() && !isLocalLlmBaseUrl(settings.baseUrl)) {
@@ -1757,15 +2715,15 @@ function createStreamParser() {
         done: true
       };
     }
-    let json;
+    let json2;
     try {
-      json = JSON.parse(data);
+      json2 = JSON.parse(data);
     } catch {
       return null;
     }
-    if (typeof json.model === "string")
-      model = json.model;
-    const choice = json.choices?.[0];
+    if (typeof json2.model === "string")
+      model = json2.model;
+    const choice = json2.choices?.[0];
     const delta = choice?.delta;
     if (!delta)
       return null;
@@ -1857,6 +2815,48 @@ async function readSseStream(body, onChunk, signal) {
   return { ...last, done: true };
 }
 
+// src/core/system-prompt.ts
+function buildSystemPromptWithTools(basePrompt, tools) {
+  const trimmedBase = basePrompt.trim();
+  if (tools.length === 0) {
+    return `${trimmedBase}
+
+## Currently enabled tools
+
+No @namespace action tools are enabled. You cannot call datastore or UI action tools until the user enables them in Settings → AI Assistant Tools.
+
+When the user asks what tools are available, say none are enabled and point them to settings. Do not invent or list disabled tool names.`;
+  }
+  const toolLines = tools.map((tool, index) => `${index + 1}. \`${tool.name}\` — ${tool.description}`);
+  return `${trimmedBase}
+
+## Currently enabled tools
+
+Only the tools below are available in this session. When listing tools, include **only** these entries — never mention disabled or hypothetical tools.
+
+${toolLines.join(`
+`)}`;
+}
+
+// src/core/tool-names.ts
+var LLM_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function toLlmToolName(name) {
+  if (LLM_TOOL_NAME_PATTERN.test(name))
+    return name;
+  if (name.startsWith("@")) {
+    return name.slice(1).replace(/\//g, "__");
+  }
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function fromLlmToolName(llmName, registryNames) {
+  if (registryNames.includes(llmName))
+    return llmName;
+  const decoded = `@${llmName.replace(/__/g, "/")}`;
+  if (registryNames.includes(decoded))
+    return decoded;
+  return llmName;
+}
+
 // src/core/llm-chat.ts
 var MAX_AGENT_STEPS = 8;
 var DEFAULT_SYSTEM_PROMPT = "You are a helpful assistant with access to tools. Use tools when they help answer the user.";
@@ -1979,12 +2979,16 @@ async function runLlmAgent(input) {
     { role: "user", content: input.userMessage }
   ];
   let lastToolResult;
+  const registryToolNames = input.tools.map((tool) => tool.name);
+  const interactiveGate = createInteractiveAgentGate();
   const clientTools = [
     ...input.tools.map(toClientTool),
     ...getChatInteractiveTools()
   ];
   let finalContent = "";
   let endedWithPostResponseTool = false;
+  const settings = await resolveAssistantLlmSettings();
+  const systemPrompt = buildSystemPromptWithTools(settings.systemPrompt ?? DEFAULT_SYSTEM_PROMPT, input.tools);
   for (let step = 0;step < MAX_AGENT_STEPS; step++) {
     if (input.signal?.aborted) {
       throw new ChatAbortedError;
@@ -1993,6 +2997,7 @@ async function runLlmAgent(input) {
       messages: apiMessages,
       tools: clientTools,
       model: input.model,
+      systemPrompt,
       signal: input.signal,
       stream: input.stream ? {
         turnId: input.stream.turnId,
@@ -2019,10 +3024,11 @@ async function runLlmAgent(input) {
     let terminatesTurn = false;
     for (const call of completion.toolCalls) {
       const args = parseToolArguments(call.function.arguments);
+      const toolName = fromLlmToolName(call.function.name, registryToolNames);
       const stepId = crypto.randomUUID();
       input.toolHandlers?.onStart({
         id: stepId,
-        name: call.function.name,
+        name: toolName,
         args,
         callId: call.id
       });
@@ -2030,15 +3036,24 @@ async function runLlmAgent(input) {
       let finishUpdate;
       if (isChatUiTool(call.function.name)) {
         try {
-          const interactiveResult = await executeChatInteractiveTool(call.function.name, args, call.id, input.signal);
-          toolContent = interactiveResult.content;
-          finishUpdate = {
-            status: interactiveResult.isError ? "error" : "done",
-            result: JSON.parse(interactiveResult.content)
-          };
-          if (interactiveResult.postResponse) {
-            input.onPostResponseTool?.(interactiveResult.postResponse);
-            terminatesTurn = true;
+          if (shouldAutoResolveInteractiveTool(interactiveGate, call.function.name, args)) {
+            toolContent = autoResolvedInteractiveResult(call.function.name, args);
+            finishUpdate = {
+              status: "done",
+              result: JSON.parse(toolContent)
+            };
+          } else {
+            recordInteractiveToolCall(interactiveGate, call.function.name);
+            const interactiveResult = await executeChatInteractiveTool(call.function.name, args, call.id, input.signal);
+            toolContent = interactiveResult.content;
+            finishUpdate = {
+              status: interactiveResult.isError ? "error" : "done",
+              result: JSON.parse(interactiveResult.content)
+            };
+            if (interactiveResult.postResponse) {
+              input.onPostResponseTool?.(interactiveResult.postResponse);
+              terminatesTurn = true;
+            }
           }
         } catch (error) {
           if (input.signal?.aborted || error instanceof DOMException && error.name === "AbortError") {
@@ -2049,7 +3064,8 @@ async function runLlmAgent(input) {
           finishUpdate = { status: "error", error: message };
         }
       } else {
-        const result = await input.invokeTool(call.function.name, args);
+        recordRegistryToolCall(interactiveGate);
+        const result = await input.invokeTool(toolName, args);
         lastToolResult = result;
         toolContent = formatToolResult(result);
         finishUpdate = {
@@ -2074,12 +3090,19 @@ async function runLlmAgent(input) {
       endedWithPostResponseTool = true;
       break;
     }
+    if (shouldInjectActionNudge(interactiveGate)) {
+      apiMessages.push({
+        role: "system",
+        content: actionToolNudgeMessage()
+      });
+    }
   }
   if (!endedWithPostResponseTool && apiMessages.at(-1)?.role === "tool") {
     const completion = await requestLlmCompletion({
       messages: apiMessages,
       tools: clientTools,
       model: input.model,
+      systemPrompt,
       signal: input.signal,
       stream: input.stream ? {
         turnId: input.stream.turnId,
@@ -2171,7 +3194,7 @@ function buildLlmHistory(messages) {
         id: `call_${baseId}_${index}`,
         type: "function",
         function: {
-          name: step.name,
+          name: toLlmToolName(step.name),
           arguments: JSON.stringify(step.args)
         }
       }));
@@ -2199,7 +3222,7 @@ function buildLlmHistory(messages) {
             id,
             type: "function",
             function: {
-              name: msg.toolCall.name,
+              name: toLlmToolName(msg.toolCall.name),
               arguments: JSON.stringify(msg.toolCall.args)
             }
           }
@@ -2262,7 +3285,7 @@ function upstreamError(body, status) {
 }
 function toClientTool(tool) {
   return {
-    name: tool.name,
+    name: toLlmToolName(tool.name),
     description: tool.description,
     inputSchema: tool.inputSchema
   };
@@ -2567,7 +3590,21 @@ function finalizeErroredMessages(messages, errorMessage) {
 function clearReplySuggestions(messages) {
   return messages.map((message) => message.replySuggestions ? { ...message, replySuggestions: undefined } : message);
 }
+function resolveAssistantStoreDependencies(deps) {
+  if (deps.toolRegistry) {
+    return {
+      ...deps,
+      listTools: () => deps.toolRegistry.listTools(),
+      invokeTool: (name, args) => deps.toolRegistry.invokeTool(name, args)
+    };
+  }
+  if (!deps.listTools || !deps.invokeTool) {
+    throw new Error("Assistant requires toolRegistry or both listTools and invokeTool");
+  }
+  return deps;
+}
 function createAssistantStore(deps) {
+  const resolvedDeps = resolveAssistantStoreDependencies(deps);
   const historyKey = deps.storageKeys?.history ?? "assistant-chat-history";
   const llmSettingsKey = deps.storageKeys?.llmSettings ?? "assistant-llm-settings";
   const llmSettingsStorage = createLlmSettingsStorage(llmSettingsKey);
@@ -2601,7 +3638,7 @@ function createAssistantStore(deps) {
   });
   const store = create((set, get) => {
     async function runLlmChatTurn(message) {
-      const tools = await deps.listTools();
+      const tools = await resolvedDeps.listTools();
       const storedMessages = get().messages.filter((m) => m.id !== "welcome");
       const priorMessages = storedMessages.at(-1)?.role === "user" ? storedMessages.slice(0, -1) : storedMessages;
       const llmHistory = buildLlmHistory(priorMessages);
@@ -2658,7 +3695,7 @@ function createAssistantStore(deps) {
           }));
         },
         invokeTool: async (name, args) => {
-          const result = await deps.invokeTool(name, args);
+          const result = await resolvedDeps.invokeTool(name, args);
           deps.onToolInvoked?.(result);
           return result;
         }
@@ -2941,7 +3978,9 @@ function parseSuggestedPromptsResponse(data) {
   return prompts.slice(0, 6);
 }
 // src/core/markdown-utils.ts
-var import_react2 = __toESM(require_react(), 1);
+function isReactElement(value) {
+  return typeof value === "object" && value !== null && "props" in value && typeof value.props === "object";
+}
 function childrenToText(children) {
   if (typeof children === "string")
     return children;
@@ -2949,13 +3988,125 @@ function childrenToText(children) {
     return String(children);
   if (Array.isArray(children))
     return children.map(childrenToText).join("");
-  if (import_react2.isValidElement(children)) {
+  if (isReactElement(children)) {
     return childrenToText(children.props.children);
   }
   return "";
 }
+// src/core/prepare-markdown.ts
+function prepareMarkdown(message) {
+  let text = convertLatexDisplayMath(message.trimStart());
+  text = convertLatexInlineMath(text);
+  return text.replace(/\n{3,}/g, `
+
+`).trimEnd();
+}
+function convertLatexInlineMath(message) {
+  return message.replace(/\\\(([\s\S]*?)\\\)/g, (_, math) => `$${math.trim()}$`);
+}
+function convertLatexDisplayMath(message) {
+  return message.replace(/(^|\n)([ \t]*?)\\\[([\s\S]*?)\\\]/g, (_full, lineStart, indent, rawMath) => {
+    const mathLines = rawMath.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+    if (mathLines.length === 0) {
+      return _full;
+    }
+    const pad = indent.length > 0 ? "   " : "";
+    const body = mathLines.map((line) => `${pad}${line}`).join(`
+`);
+    return `${lineStart}${pad}$$
+${body}
+${pad}$$`;
+  });
+}
+// src/core/tool-registry.ts
+function toolResultOk(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}
+function toolResultErr(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+class AssistantToolRegistryImpl {
+  entries = new Map;
+  register(handler) {
+    const name = handler.definition.name;
+    if (!name.trim()) {
+      throw new Error("Tool definition.name is required");
+    }
+    this.entries.set(name, { handler, active: true });
+    return this;
+  }
+  deactivate(name) {
+    const entry = this.entries.get(name);
+    if (!entry)
+      return false;
+    entry.active = false;
+    return true;
+  }
+  activate(name) {
+    const entry = this.entries.get(name);
+    if (!entry)
+      return false;
+    entry.active = true;
+    return true;
+  }
+  isActive(name) {
+    const entry = this.entries.get(name);
+    return entry?.active ?? false;
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  async listTools() {
+    return [...this.entries.values()].filter((entry) => entry.active).map((entry) => entry.handler.definition);
+  }
+  async invokeTool(name, args) {
+    const entry = this.entries.get(name);
+    if (!entry?.active) {
+      return toolResultErr(`Unknown tool: ${name}`);
+    }
+    try {
+      return await entry.handler.invoke(args);
+    } catch (error) {
+      return toolResultErr(error instanceof Error ? error.message : String(error));
+    }
+  }
+}
+function createAssistantToolRegistry() {
+  return new AssistantToolRegistryImpl;
+}
+function resolveAssistantToolHooks(registry) {
+  return {
+    listTools: () => registry.listTools(),
+    invokeTool: (name, args) => registry.invokeTool(name, args)
+  };
+}
+function connectExternalTools(registry, external) {
+  const names = external.listTools().map((definition) => {
+    registry.register({
+      definition,
+      invoke: (args) => external.invokeTool(definition.name, args)
+    });
+    return definition.name;
+  });
+  return () => {
+    for (const name of names) {
+      registry.deactivate(name);
+    }
+  };
+}
 export {
+  toolResultOk,
+  toolResultErr,
   toStoredSettings,
+  toLlmToolName,
   testLlmConnection,
   summarizeActivityResult,
   storedToAssistant,
@@ -2966,11 +4117,14 @@ export {
   runAssistantChatCommand,
   resolveSelectedModel,
   resolveInteractiveToolResult,
+  resolveAssistantToolHooks,
+  resolveAssistantStoreDependencies,
   resolveAssistantLlmSettings,
   resolveAssistantLabels,
   resetAssistantLlm,
   requestLlmCompletion,
   rejectAllInteractiveToolWaiters,
+  prepareMarkdown,
   persistStoredModelSelection,
   peekStoredModel,
   parseSuggestedPromptsResponse,
@@ -2978,6 +4132,7 @@ export {
   parseChatCommand,
   normalizeStoredSystemPrompt,
   normalizeStoredSettings,
+  normalizeCodeLineEndings,
   migrateLegacyModelStorage,
   mergeLlmSettings,
   listChatCommands,
@@ -2986,8 +4141,10 @@ export {
   isLlmSettingsFormDirty,
   isLlmConfigured,
   isChatCommandInput,
+  highlightCode,
   getFallbackModels,
   getChatCommandSuggestions,
+  fromLlmToolName,
   formatModelsText,
   formatLabel,
   formatJsonIfLarge,
@@ -2999,11 +4156,15 @@ export {
   createLlmSettingsFormState,
   createDefaultStoredSettings,
   createChatHistoryHelpers,
+  createAssistantToolRegistry,
   createAssistantStore,
+  connectExternalTools,
   configureAssistantLlm,
+  completionForChatCommand,
   clearProviderModelCache,
   childrenToText,
   chatActivityStepLabel,
+  buildSystemPromptWithTools,
   buildModelsUrl,
   buildLlmRequestHeaders,
   buildLlmHistory,