import {
  addGeneSearchbox,
  appear2 as appear,
  newSandboxDiv,
  sayerror,
  tab_wait
} from "./chunk-SA7APTJR.js";
import {
  Menu
} from "./chunk-HYOEWQ5P.js";
import {
  Tabs
} from "./chunk-HBW42TDT.js";
import {
  dofetch,
  dofetch3
} from "./chunk-7EMWHCVW.js";
import {
  select_default
} from "./chunk-I6Y4O3RR.js";
import {
  __commonJS,
  __toESM
} from "./chunk-HFNDKYVF.js";

// ../node_modules/highlight.js/lib/core.js
var require_core = __commonJS({
  "../node_modules/highlight.js/lib/core.js"(exports, module) {
    var deepFreezeEs6 = { exports: {} };
    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");
        };
      }
      Object.freeze(obj);
      Object.getOwnPropertyNames(obj).forEach(function(name) {
        var prop = obj[name];
        if (typeof prop == "object" && !Object.isFrozen(prop)) {
          deepFreeze(prop);
        }
      });
      return obj;
    }
    deepFreezeEs6.exports = deepFreeze;
    deepFreezeEs6.exports.default = deepFreeze;
    var deepFreeze$1 = deepFreezeEs6.exports;
    var Response = class {
      /**
       * @param {CompiledMode} mode
       */
      constructor(mode) {
        if (mode.data === void 0) 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 = /* @__PURE__ */ 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 (
        /** @type {T} */
        result
      );
    }
    var SPAN_CLOSE = "</span>";
    var emitsWrappingTags = (node) => {
      return !!node.kind;
    };
    var expandScopeName = (name, { prefix }) => {
      if (name.includes(".")) {
        const pieces = name.split(".");
        return [
          `${prefix}${pieces.shift()}`,
          ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
        ].join(" ");
      }
      return `${prefix}${name}`;
    };
    var HTMLRenderer = class {
      /**
       * Creates a new HTMLRenderer
       *
       * @param {Tree} parseTree - the parse tree (must support `walk` API)
       * @param {{classPrefix: string}} options
       */
      constructor(parseTree, options) {
        this.buffer = "";
        this.classPrefix = options.classPrefix;
        parseTree.walk(this);
      }
      /**
       * Adds texts to the output stream
       *
       * @param {string} text */
      addText(text) {
        this.buffer += escapeHTML(text);
      }
      /**
       * Adds a node open to the output stream (if needed)
       *
       * @param {Node} node */
      openNode(node) {
        if (!emitsWrappingTags(node)) return;
        let scope = node.kind;
        if (node.sublanguage) {
          scope = `language-${scope}`;
        } else {
          scope = expandScopeName(scope, { prefix: this.classPrefix });
        }
        this.span(scope);
      }
      /**
       * Adds a node close to the output stream (if needed)
       *
       * @param {Node} node */
      closeNode(node) {
        if (!emitsWrappingTags(node)) return;
        this.buffer += SPAN_CLOSE;
      }
      /**
       * returns the accumulated buffer
      */
      value() {
        return this.buffer;
      }
      // helpers
      /**
       * Builds a span element
       *
       * @param {string} className */
      span(className) {
        this.buffer += `<span class="${className}">`;
      }
    };
    var TokenTree = class _TokenTree {
      constructor() {
        this.rootNode = { children: [] };
        this.stack = [this.rootNode];
      }
      get top() {
        return this.stack[this.stack.length - 1];
      }
      get root() {
        return this.rootNode;
      }
      /** @param {Node} node */
      add(node) {
        this.top.children.push(node);
      }
      /** @param {string} kind */
      openNode(kind) {
        const node = { kind, children: [] };
        this.add(node);
        this.stack.push(node);
      }
      closeNode() {
        if (this.stack.length > 1) {
          return this.stack.pop();
        }
        return void 0;
      }
      closeAllNodes() {
        while (this.closeNode()) ;
      }
      toJSON() {
        return JSON.stringify(this.rootNode, null, 4);
      }
      /**
       * @typedef { import("./html_renderer").Renderer } Renderer
       * @param {Renderer} builder
       */
      walk(builder) {
        return this.constructor._walk(builder, this.rootNode);
      }
      /**
       * @param {Renderer} builder
       * @param {Node} node
       */
      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 builder;
      }
      /**
       * @param {Node} node
       */
      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);
          });
        }
      }
    };
    var TokenTreeEmitter = class extends TokenTree {
      /**
       * @param {*} options
       */
      constructor(options) {
        super();
        this.options = options;
      }
      /**
       * @param {string} text
       * @param {string} kind
       */
      addKeyword(text, kind) {
        if (text === "") {
          return;
        }
        this.openNode(kind);
        this.addText(text);
        this.closeNode();
      }
      /**
       * @param {string} text
       */
      addText(text) {
        if (text === "") {
          return;
        }
        this.add(text);
      }
      /**
       * @param {Emitter & {root: DataNode}} emitter
       * @param {string} name
       */
      addSublanguage(emitter, name) {
        const node = emitter.root;
        node.kind = name;
        node.sublanguage = true;
        this.add(node);
      }
      toHTML() {
        const renderer = new HTMLRenderer(this, this.options);
        return renderer.value();
      }
      finalize() {
        return true;
      }
    };
    function source2(re) {
      if (!re) return null;
      if (typeof re === "string") return re;
      return re.source;
    }
    function lookahead2(re) {
      return concat2("(?=", re, ")");
    }
    function concat2(...args) {
      const joined = args.map((x) => source2(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) => source2(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 = source2(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_RE2 = "[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 = concat2(
          beginShebang,
          /.*\b/,
          opts.binary,
          /\b.*/
        );
      }
      return inherit$1({
        scope: "meta",
        begin: beginShebang,
        end: /$/,
        relevance: 0,
        /** @type {ModeCallback} */
        "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",
        // hack to avoid the space from being included. the space is necessary to
        // match here to prevent the plain text rule below from gobbling up doctags
        begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
        end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
        excludeBegin: true,
        relevance: 0
      });
      const ENGLISH_WORD = either(
        // list of common 1 and 2 letter words in English
        "I",
        "a",
        "is",
        "so",
        "us",
        "to",
        "at",
        "if",
        "in",
        "it",
        "on",
        // note: this is not an exhaustive list of contractions, just popular ones
        /[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
        // contractions - can't we'd they're let's, etc
        /[A-Za-z]+[-][a-z]+/,
        // `no-way`, etc.
        /[A-Za-z][a-z]{2,}/
        // allow capitalized words at beginning of sentences
      );
      mode.contains.push(
        {
          // TODO: how to include ", (, ) without breaking grammars that use these for
          // comment delimiters?
          // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
          // ---
          // this tries to find sequences of 3 english words in a row (without any
          // "programming" type syntax) this gives us a strong signal that we've
          // TRULY found a comment - vs perhaps scanning with the wrong language.
          // It's possible to find something that LOOKS like the start of the
          // comment - but then if there is no readable text - good chance it is a
          // false match and not a comment.
          //
          // for a visual example please see:
          // https://github.com/highlightjs/highlight.js/issues/2827
          begin: concat2(
            /[ ]+/,
            // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
            "(",
            ENGLISH_WORD,
            /[.]?[:]?([.][ ]|[ ])/,
            "){3}"
          )
          // look for 3 words in a row
        }
      );
      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 = {
      // this outer rule makes sure we actually have a WHOLE regex and not simply
      // an expression such as:
      //
      //     3 / something
      //
      // (which will then blow up when regex's `illegal` sees the newline)
      begin: /(?=\/[^/\n]*\/)/,
      contains: [{
        scope: "regexp",
        begin: /\//,
        end: /\/[gimuy]*/,
        illegal: /\n/,
        contains: [
          BACKSLASH_ESCAPE,
          {
            begin: /\[/,
            end: /\]/,
            relevance: 0,
            contains: [BACKSLASH_ESCAPE]
          }
        ]
      }]
    };
    var TITLE_MODE = {
      scope: "title",
      begin: IDENT_RE2,
      relevance: 0
    };
    var UNDERSCORE_TITLE_MODE = {
      scope: "title",
      begin: UNDERSCORE_IDENT_RE,
      relevance: 0
    };
    var METHOD_GUARD = {
      // excludes method names from keyword processing
      begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
      relevance: 0
    };
    var END_SAME_AS_BEGIN = function(mode) {
      return Object.assign(
        mode,
        {
          /** @type {ModeCallback} */
          "on:begin": (m, resp) => {
            resp.data._beginMatch = m[1];
          },
          /** @type {ModeCallback} */
          "on:end": (m, resp) => {
            if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
          }
        }
      );
    };
    var MODES = /* @__PURE__ */ Object.freeze({
      __proto__: null,
      MATCH_NOTHING_RE,
      IDENT_RE: IDENT_RE2,
      UNDERSCORE_IDENT_RE,
      NUMBER_RE,
      C_NUMBER_RE,
      BINARY_NUMBER_RE,
      RE_STARTERS_RE,
      SHEBANG,
      BACKSLASH_ESCAPE,
      APOS_STRING_MODE,
      QUOTE_STRING_MODE,
      PHRASAL_WORDS_MODE,
      COMMENT,
      C_LINE_COMMENT_MODE,
      C_BLOCK_COMMENT_MODE,
      HASH_COMMENT_MODE,
      NUMBER_MODE,
      C_NUMBER_MODE,
      BINARY_NUMBER_MODE,
      REGEXP_MODE,
      TITLE_MODE,
      UNDERSCORE_TITLE_MODE,
      METHOD_GUARD,
      END_SAME_AS_BEGIN
    });
    function skipIfHasPrecedingDot(match, response) {
      const before = match.input[match.index - 1];
      if (before === ".") {
        response.ignoreMatch();
      }
    }
    function scopeClassName(mode, _parent) {
      if (mode.className !== void 0) {
        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 === void 0) 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 === void 0) 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 = concat2(originalMode.beforeMatch, lookahead2(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",
      // common variable name
      "list",
      // common variable name
      "value"
      // common variable name
    ];
    var DEFAULT_KEYWORD_SCOPE = "keyword";
    function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
      const compiledKeywords = /* @__PURE__ */ 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)
          );
        });
      }
      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])];
        });
      }
    }
    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;
      }
      if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
        error("beginScope must be object");
        throw MultiClassError;
      }
      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;
      }
      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(
          source2(value),
          "m" + (language.case_insensitive ? "i" : "") + (global ? "g" : "")
        );
      }
      class MultiRegex {
        constructor() {
          this.matchIndexes = {};
          this.regexes = [];
          this.matchAt = 1;
          this.position = 0;
        }
        // @ts-ignore
        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;
        }
        /** @param {string} s */
        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 !== void 0);
          const matchData = this.matchIndexes[i];
          match.splice(0, i);
          return Object.assign(match, matchData);
        }
      }
      class ResumableMultiRegex {
        constructor() {
          this.rules = [];
          this.multiRegexes = [];
          this.count = 0;
          this.lastIndex = 0;
          this.regexIndex = 0;
        }
        // @ts-ignore
        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;
        }
        // @ts-ignore
        addRule(re, opts) {
          this.rules.push([re, opts]);
          if (opts.type === "begin") this.count++;
        }
        /** @param {string} s */
        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;
        }
      }
      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 = (
          /** @type CompiledMode */
          mode
        );
        if (mode.isCompiled) return cmode;
        [
          scopeClassName,
          // do this early so compiler extensions generally don't have to worry about
          // the distinction between match/begin
          compileMatch,
          MultiClass,
          beforeMatchExt
        ].forEach((ext) => ext(mode, parent));
        language.compilerExtensions.forEach((ext) => ext(mode, parent));
        mode.__beforeBegin = null;
        [
          beginKeywords,
          // do this later so compiler extensions that come earlier have access to the
          // raw array if they wanted to perhaps manipulate it, etc.
          compileIllegal,
          // default to 1 relevance if not specified
          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(mode.begin);
          if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
          if (mode.end) cmode.endRe = langRe(mode.end);
          cmode.terminatorEnd = source2(mode.end) || "";
          if (mode.endsWithParent && parent.terminatorEnd) {
            cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
          }
        }
        if (mode.illegal) cmode.illegalRe = langRe(
          /** @type {RegExp | string} */
          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(
            /** @type Mode */
            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(
        /** @type Mode */
        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.2.0";
    var escape = escapeHTML;
    var inherit = inherit$1;
    var NO_MATCH = Symbol("nomatch");
    var MAX_KEYWORD_HITS = 7;
    var HLJS = function(hljs2) {
      const languages = /* @__PURE__ */ Object.create(null);
      const aliases = /* @__PURE__ */ 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,
        noHighlightRe: /^(no-?highlight)$/i,
        languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
        classPrefix: "hljs-",
        cssSelector: "pre code",
        languages: null,
        // beta configuration options, subject to change, welcome to discuss
        // https://github.com/highlightjs/highlight.js/issues/1086
        __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.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
          languageName = codeOrLanguageName;
          code = optionsOrCode;
        }
        if (ignoreIllegals === void 0) {
          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 _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
        const keywordHits = /* @__PURE__ */ 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;
                emitter.addKeyword(match[0], cssClass);
              }
            } else {
              buf += match[0];
            }
            lastIndex = top.keywordPatternRe.lastIndex;
            match = top.keywordPatternRe.exec(modeBuffer);
          }
          buf += modeBuffer.substr(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;
            }
            result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
            continuations[top.subLanguage] = /** @type {CompiledMode} */
            result2._top;
          } else {
            result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
          }
          if (top.relevance > 0) {
            relevance += result2.relevance;
          }
          emitter.addSublanguage(result2._emitter, result2.language);
        }
        function processBuffer() {
          if (top.subLanguage != null) {
            processSubLanguage();
          } else {
            processKeywords();
          }
          modeBuffer = "";
        }
        function emitMultiClass(scope, match) {
          let i = 1;
          while (match[i] !== void 0) {
            if (!scope._emit[i]) {
              i++;
              continue;
            }
            const klass = language.classNameAliases[scope[i]] || scope[i];
            const text = match[i];
            if (klass) {
              emitter.addKeyword(text, klass);
            } else {
              modeBuffer = text;
              processKeywords();
              modeBuffer = "";
            }
            i++;
          }
        }
        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) {
              emitter.addKeyword(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;
        }
        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);
          }
        }
        function doIgnore(lexeme) {
          if (top.matcher.regexIndex === 0) {
            modeBuffer += lexeme[0];
            return 1;
          } else {
            resumeScanAtSamePosition = true;
            return 0;
          }
        }
        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;
        }
        function doEndMatch(match) {
          const lexeme = match[0];
          const matchPlusRemainder = codeToHighlight.substr(match.index);
          const endMode = endOfMode(top, match, matchPlusRemainder);
          if (!endMode) {
            return NO_MATCH;
          }
          const origin = top;
          if (top.endScope && top.endScope._wrap) {
            processBuffer();
            emitter.addKeyword(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;
        }
        function processContinuations() {
          const list = [];
          for (let current = top; current !== language; current = current.parent) {
            if (current.scope) {
              list.unshift(current.scope);
            }
          }
          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;
            }
            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 === "") {
            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 {
          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.substr(index));
          emitter.closeAllNodes();
          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;
          }
        }
      }
      function justTextHighlightResult(code) {
        const result = {
          value: escape(code),
          illegal: false,
          relevance: 0,
          _top: PLAINTEXT_LANGUAGE,
          _emitter: new options.__emitter(options)
        };
        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;
        });
        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 (!options.ignoreUnescapedHTML && element.children.length > 0) {
          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/issues/2886");
          console.warn(element);
        }
        node = element;
        const text = node.textContent;
        const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
        element.innerHTML = result.value;
        updateClassName(element, language, result.language);
        element.result = {
          language: result.language,
          // TODO: remove with version 11.0
          re: result.relevance,
          relevance: result.relevance
        };
        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.");
      };
      function initHighlightingOnLoad() {
        highlightAll();
        deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
      }
      let wantsHighlight = false;
      function highlightAll() {
        if (document.readyState === "loading") {
          wantsHighlight = true;
          return;
        }
        const blocks = document.querySelectorAll(options.cssSelector);
        blocks.forEach(highlightElement);
      }
      function boot() {
        if (wantsHighlight) highlightAll();
      }
      if (typeof window !== "undefined" && window.addEventListener) {
        window.addEventListener("DOMContentLoaded", boot, false);
      }
      function registerLanguage(languageName, languageDefinition) {
        let lang = null;
        try {
          lang = languageDefinition(hljs2);
        } 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, hljs2);
        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 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(hljs2, {
        highlight: highlight2,
        highlightAuto,
        highlightAll,
        highlightElement,
        // TODO: Remove with v12 API
        highlightBlock: deprecateHighlightBlock,
        configure,
        initHighlighting,
        initHighlightingOnLoad,
        registerLanguage,
        unregisterLanguage,
        listLanguages,
        getLanguage,
        registerAliases,
        autoDetection,
        inherit,
        addPlugin
      });
      hljs2.debugMode = function() {
        SAFE_MODE = false;
      };
      hljs2.safeMode = function() {
        SAFE_MODE = true;
      };
      hljs2.versionString = version;
      for (const key in MODES) {
        if (typeof MODES[key] === "object") {
          deepFreeze$1(MODES[key]);
        }
      }
      Object.assign(hljs2, MODES);
      return hljs2;
    };
    var highlight = HLJS({});
    module.exports = highlight;
  }
});

// appdrawer/utils.js
function makeButton(arg) {
  const button = arg.div.append("button").attr("type", "submit").style("background-color", arg.backgroundColor ? arg.backgroundColor : "#cfe2f3").style("margin", arg.margin ? arg.margin : "20px 20px 0px 20px").style("padding", "8px").style("border", "none").style("border-radius", "3px").style("display", "inline-block").text(arg.text);
  return button;
}

// dom/breadcrumbs.js
var BreadcrumbTrail = class {
  constructor(opts) {
    this.opts = opts;
    this.dom = {
      holder: opts.holder,
      trailDiv: opts.trailDiv || opts.holder.append("div")
    };
    setRenderers(this);
  }
  async main(opts = {}) {
    try {
      return await this.render();
    } catch (e) {
      if (e.stack) console.log(e.stack);
      else throw e;
    }
  }
};
function setRenderers(self) {
  self.render = async () => {
    self.crumbs = self.opts.crumbs;
    for (const crumb of self.crumbs) {
      crumb.label = crumb.label || crumb.name;
      if (!crumb.inTrail) crumb.inTrail = false;
    }
    const has_active_crumb = self.crumbs.find((crumb) => crumb.inTrail);
    if (!has_active_crumb) self.crumbs[0].inTrail = true;
    await self.dom.trailDiv.style("margin-left", "5px").style("font-size", ".75em").style("display", "inline-block").classed("sjpp-breadcrumb-trail", true).selectAll("span").data(self.crumbs).enter().append("span").classed("sjpp-breadcrumb", true).html((crumb) => crumb.link ? `&nbsp> <a href="${crumb.link}">${crumb.label}</a>` : `&nbsp> ${crumb.label}`).style("display", (crumb) => crumb.inTrail ? "inline-block" : "none").each(async function(crumb) {
      crumb.div = select_default(this);
    });
    const activeCrumbIndex = self.crumbs.findIndex((c) => c.inTrail);
    self.update(activeCrumbIndex);
  };
  self.update = (crumbIndex = 0) => {
    self.crumbs.forEach((crumb, i) => {
      crumb.inTrail = crumbIndex === i;
    });
    self.dom.trailDiv.selectAll("span").data(self.crumbs).each(async (crumb) => {
      crumb.div.style("display", crumb.inTrail ? "inline-block" : "none");
    });
  };
}

// ../node_modules/highlight.js/es/core.js
var import_core = __toESM(require_core(), 1);
var core_default = import_core.default;

// ../node_modules/highlight.js/es/languages/javascript.js
var IDENT_RE = "[A-Za-z$_][0-9A-Za-z$_]*";
var KEYWORDS = [
  "as",
  // for exports
  "in",
  "of",
  "if",
  "for",
  "while",
  "finally",
  "var",
  "new",
  "function",
  "do",
  "return",
  "void",
  "else",
  "break",
  "catch",
  "instanceof",
  "with",
  "throw",
  "case",
  "default",
  "try",
  "switch",
  "continue",
  "typeof",
  "delete",
  "let",
  "yield",
  "const",
  "class",
  // JS handles these with a special rule
  // "get",
  // "set",
  "debugger",
  "async",
  "await",
  "static",
  "import",
  "from",
  "export",
  "extends"
];
var LITERALS = [
  "true",
  "false",
  "null",
  "undefined",
  "NaN",
  "Infinity"
];
var TYPES = [
  "Intl",
  "DataView",
  "Number",
  "Math",
  "Date",
  "String",
  "RegExp",
  "Object",
  "Function",
  "Boolean",
  "Error",
  "Symbol",
  "Set",
  "Map",
  "WeakSet",
  "WeakMap",
  "Proxy",
  "Reflect",
  "JSON",
  "Promise",
  "Float64Array",
  "Int16Array",
  "Int32Array",
  "Int8Array",
  "Uint16Array",
  "Uint32Array",
  "Float32Array",
  "Array",
  "Uint8Array",
  "Uint8ClampedArray",
  "ArrayBuffer",
  "BigInt64Array",
  "BigUint64Array",
  "BigInt"
];
var ERROR_TYPES = [
  "EvalError",
  "InternalError",
  "RangeError",
  "ReferenceError",
  "SyntaxError",
  "TypeError",
  "URIError"
];
var BUILT_IN_GLOBALS = [
  "setInterval",
  "setTimeout",
  "clearInterval",
  "clearTimeout",
  "require",
  "exports",
  "eval",
  "isFinite",
  "isNaN",
  "parseFloat",
  "parseInt",
  "decodeURI",
  "decodeURIComponent",
  "encodeURI",
  "encodeURIComponent",
  "escape",
  "unescape"
];
var BUILT_IN_VARIABLES = [
  "arguments",
  "this",
  "super",
  "console",
  "window",
  "document",
  "localStorage",
  "module",
  "global"
  // Node.js
];
var BUILT_INS = [].concat(
  BUILT_IN_GLOBALS,
  TYPES,
  ERROR_TYPES
);
function source(re) {
  if (!re) return null;
  if (typeof re === "string") return re;
  return re.source;
}
function lookahead(re) {
  return concat("(?=", re, ")");
}
function concat(...args) {
  const joined = args.map((x) => source(x)).join("");
  return joined;
}
function javascript(hljs2) {
  const hasClosingTag = (match, { after }) => {
    const tag = "</" + match[0].slice(1);
    const pos = match.input.indexOf(tag, after);
    return pos !== -1;
  };
  const IDENT_RE$1 = IDENT_RE;
  const FRAGMENT = {
    begin: "<>",
    end: "</>"
  };
  const XML_TAG = {
    begin: /<[A-Za-z0-9\\._:-]+/,
    end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
    /**
     * @param {RegExpMatchArray} match
     * @param {CallbackResponse} response
     */
    isTrulyOpeningTag: (match, response) => {
      const afterMatchIndex = match[0].length + match.index;
      const nextChar = match.input[afterMatchIndex];
      if (nextChar === "<") {
        response.ignoreMatch();
        return;
      }
      if (nextChar === ">") {
        if (!hasClosingTag(match, { after: afterMatchIndex })) {
          response.ignoreMatch();
        }
      }
    }
  };
  const KEYWORDS$1 = {
    $pattern: IDENT_RE,
    keyword: KEYWORDS,
    literal: LITERALS,
    built_in: BUILT_INS,
    "variable.language": BUILT_IN_VARIABLES
  };
  const decimalDigits = "[0-9](_?[0-9])*";
  const frac = `\\.(${decimalDigits})`;
  const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
  const NUMBER = {
    className: "number",
    variants: [
      // DecimalLiteral
      { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
      { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
      // DecimalBigIntegerLiteral
      { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
      // NonDecimalIntegerLiteral
      { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
      { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
      { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
      // LegacyOctalIntegerLiteral (does not include underscore separators)
      // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
      { begin: "\\b0[0-7]+n?\\b" }
    ],
    relevance: 0
  };
  const SUBST = {
    className: "subst",
    begin: "\\$\\{",
    end: "\\}",
    keywords: KEYWORDS$1,
    contains: []
    // defined later
  };
  const HTML_TEMPLATE = {
    begin: "html`",
    end: "",
    starts: {
      end: "`",
      returnEnd: false,
      contains: [
        hljs2.BACKSLASH_ESCAPE,
        SUBST
      ],
      subLanguage: "xml"
    }
  };
  const CSS_TEMPLATE = {
    begin: "css`",
    end: "",
    starts: {
      end: "`",
      returnEnd: false,
      contains: [
        hljs2.BACKSLASH_ESCAPE,
        SUBST
      ],
      subLanguage: "css"
    }
  };
  const TEMPLATE_STRING = {
    className: "string",
    begin: "`",
    end: "`",
    contains: [
      hljs2.BACKSLASH_ESCAPE,
      SUBST
    ]
  };
  const JSDOC_COMMENT = hljs2.COMMENT(
    /\/\*\*(?!\/)/,
    "\\*/",
    {
      relevance: 0,
      contains: [
        {
          begin: "(?=@[A-Za-z]+)",
          relevance: 0,
          contains: [
            {
              className: "doctag",
              begin: "@[A-Za-z]+"
            },
            {
              className: "type",
              begin: "\\{",
              end: "\\}",
              excludeEnd: true,
              excludeBegin: true,
              relevance: 0
            },
            {
              className: "variable",
              begin: IDENT_RE$1 + "(?=\\s*(-)|$)",
              endsParent: true,
              relevance: 0
            },
            // eat spaces (not newlines) so we can find
            // types or variables
            {
              begin: /(?=[^\n])\s/,
              relevance: 0
            }
          ]
        }
      ]
    }
  );
  const COMMENT = {
    className: "comment",
    variants: [
      JSDOC_COMMENT,
      hljs2.C_BLOCK_COMMENT_MODE,
      hljs2.C_LINE_COMMENT_MODE
    ]
  };
  const SUBST_INTERNALS = [
    hljs2.APOS_STRING_MODE,
    hljs2.QUOTE_STRING_MODE,
    HTML_TEMPLATE,
    CSS_TEMPLATE,
    TEMPLATE_STRING,
    NUMBER,
    hljs2.REGEXP_MODE
  ];
  SUBST.contains = SUBST_INTERNALS.concat({
    // we need to pair up {} inside our subst to prevent
    // it from ending too early by matching another }
    begin: /\{/,
    end: /\}/,
    keywords: KEYWORDS$1,
    contains: [
      "self"
    ].concat(SUBST_INTERNALS)
  });
  const SUBST_AND_COMMENTS = [].concat(COMMENT, SUBST.contains);
  const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
    // eat recursive parens in sub expressions
    {
      begin: /\(/,
      end: /\)/,
      keywords: KEYWORDS$1,
      contains: ["self"].concat(SUBST_AND_COMMENTS)
    }
  ]);
  const PARAMS = {
    className: "params",
    begin: /\(/,
    end: /\)/,
    excludeBegin: true,
    excludeEnd: true,
    keywords: KEYWORDS$1,
    contains: PARAMS_CONTAINS
  };
  const CLASS_OR_EXTENDS = {
    variants: [
      {
        match: [
          /class/,
          /\s+/,
          IDENT_RE$1
        ],
        scope: {
          1: "keyword",
          3: "title.class"
        }
      },
      {
        match: [
          /extends/,
          /\s+/,
          concat(IDENT_RE$1, "(", concat(/\./, IDENT_RE$1), ")*")
        ],
        scope: {
          1: "keyword",
          3: "title.class.inherited"
        }
      }
    ]
  };
  const CLASS_REFERENCE = {
    relevance: 0,
    match: /\b[A-Z][a-z]+([A-Z][a-z]+)*/,
    className: "title.class",
    keywords: {
      _: [
        // se we still get relevance credit for JS library classes
        ...TYPES,
        ...ERROR_TYPES
      ]
    }
  };
  const USE_STRICT = {
    label: "use_strict",
    className: "meta",
    relevance: 10,
    begin: /^\s*['"]use (strict|asm)['"]/
  };
  const FUNCTION_DEFINITION = {
    variants: [
      {
        match: [
          /function/,
          /\s+/,
          IDENT_RE$1,
          /(?=\s*\()/
        ]
      },
      // anonymous function
      {
        match: [
          /function/,
          /\s*(?=\()/
        ]
      }
    ],
    className: {
      1: "keyword",
      3: "title.function"
    },
    label: "func.def",
    contains: [PARAMS],
    illegal: /%/
  };
  const UPPER_CASE_CONSTANT = {
    relevance: 0,
    match: /\b[A-Z][A-Z_0-9]+\b/,
    className: "variable.constant"
  };
  function noneOf(list) {
    return concat("(?!", list.join("|"), ")");
  }
  const FUNCTION_CALL = {
    match: concat(
      /\b/,
      noneOf([
        ...BUILT_IN_GLOBALS,
        "super"
      ]),
      IDENT_RE$1,
      lookahead(/\(/)
    ),
    className: "title.function",
    relevance: 0
  };
  const PROPERTY_ACCESS = {
    begin: concat(/\./, lookahead(
      concat(IDENT_RE$1, /(?![0-9A-Za-z$_(])/)
    )),
    end: IDENT_RE$1,
    excludeBegin: true,
    keywords: "prototype",
    className: "property",
    relevance: 0
  };
  const GETTER_OR_SETTER = {
    match: [
      /get|set/,
      /\s+/,
      IDENT_RE$1,
      /(?=\()/
    ],
    className: {
      1: "keyword",
      3: "title.function"
    },
    contains: [
      {
        // eat to avoid empty params
        begin: /\(\)/
      },
      PARAMS
    ]
  };
  const FUNC_LEAD_IN_RE = "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs2.UNDERSCORE_IDENT_RE + ")\\s*=>";
  const FUNCTION_VARIABLE = {
    match: [
      /const|var|let/,
      /\s+/,
      IDENT_RE$1,
      /\s*/,
      /=\s*/,
      lookahead(FUNC_LEAD_IN_RE)
    ],
    className: {
      1: "keyword",
      3: "title.function"
    },
    contains: [
      PARAMS
    ]
  };
  return {
    name: "Javascript",
    aliases: ["js", "jsx", "mjs", "cjs"],
    keywords: KEYWORDS$1,
    // this will be extended by TypeScript
    exports: { PARAMS_CONTAINS },
    illegal: /#(?![$_A-z])/,
    contains: [
      hljs2.SHEBANG({
        label: "shebang",
        binary: "node",
        relevance: 5
      }),
      USE_STRICT,
      hljs2.APOS_STRING_MODE,
      hljs2.QUOTE_STRING_MODE,
      HTML_TEMPLATE,
      CSS_TEMPLATE,
      TEMPLATE_STRING,
      COMMENT,
      NUMBER,
      CLASS_REFERENCE,
      {
        className: "attr",
        begin: IDENT_RE$1 + lookahead(":"),
        relevance: 0
      },
      FUNCTION_VARIABLE,
      {
        // "value" container
        begin: "(" + hljs2.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
        keywords: "return throw case",
        relevance: 0,
        contains: [
          COMMENT,
          hljs2.REGEXP_MODE,
          {
            className: "function",
            // we have to count the parens to make sure we actually have the
            // correct bounding ( ) before the =>.  There could be any number of
            // sub-expressions inside also surrounded by parens.
            begin: FUNC_LEAD_IN_RE,
            returnBegin: true,
            end: "\\s*=>",
            contains: [
              {
                className: "params",
                variants: [
                  {
                    begin: hljs2.UNDERSCORE_IDENT_RE,
                    relevance: 0
                  },
                  {
                    className: null,
                    begin: /\(\s*\)/,
                    skip: true
                  },
                  {
                    begin: /\(/,
                    end: /\)/,
                    excludeBegin: true,
                    excludeEnd: true,
                    keywords: KEYWORDS$1,
                    contains: PARAMS_CONTAINS
                  }
                ]
              }
            ]
          },
          {
            // could be a comma delimited list of params to a function call
            begin: /,/,
            relevance: 0
          },
          {
            match: /\s+/,
            relevance: 0
          },
          {
            // JSX
            variants: [
              { begin: FRAGMENT.begin, end: FRAGMENT.end },
              {
                begin: XML_TAG.begin,
                // we carefully check the opening tag to see if it truly
                // is a tag and not a false positive
                "on:begin": XML_TAG.isTrulyOpeningTag,
                end: XML_TAG.end
              }
            ],
            subLanguage: "xml",
            contains: [
              {
                begin: XML_TAG.begin,
                end: XML_TAG.end,
                skip: true,
                contains: ["self"]
              }
            ]
          }
        ]
      },
      FUNCTION_DEFINITION,
      {
        // prevent this from getting swallowed up by function
        // since they appear "function like"
        beginKeywords: "while if switch catch for"
      },
      {
        // we have to count the parens to make sure we actually have the correct
        // bounding ( ).  There could be any number of sub-expressions inside
        // also surrounded by parens.
        begin: "\\b(?!function)" + hljs2.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
        // end parens
        returnBegin: true,
        label: "func.def",
        contains: [
          PARAMS,
          hljs2.inherit(hljs2.TITLE_MODE, { begin: IDENT_RE$1, className: "title.function" })
        ]
      },
      // catch ... so it won't trigger the property rule below
      {
        match: /\.\.\./,
        relevance: 0
      },
      PROPERTY_ACCESS,
      // hack: prevents detection of keywords in some circumstances
      // .keyword()
      // $keyword = x
      {
        match: "\\$" + IDENT_RE$1,
        relevance: 0
      },
      {
        match: [/\bconstructor(?=\s*\()/],
        className: { 1: "title.function" },
        contains: [PARAMS]
      },
      FUNCTION_CALL,
      UPPER_CASE_CONSTANT,
      CLASS_OR_EXTENDS,
      GETTER_OR_SETTER,
      {
        match: /\$[(.]/
        // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
      }
    ]
  };
}
var javascript_default = javascript;

// ../node_modules/highlight.js/es/languages/json.js
function json(hljs2) {
  const ATTRIBUTE = {
    className: "attr",
    begin: /"(\\.|[^\\"\r\n])*"(?=\s*:)/,
    relevance: 1.01
  };
  const PUNCTUATION = {
    match: /[{}[\],:]/,
    className: "punctuation",
    relevance: 0
  };
  const LITERALS2 = {
    beginKeywords: [
      "true",
      "false",
      "null"
    ].join(" ")
  };
  return {
    name: "JSON",
    contains: [
      ATTRIBUTE,
      PUNCTUATION,
      hljs2.QUOTE_STRING_MODE,
      LITERALS2,
      hljs2.C_NUMBER_MODE,
      hljs2.C_LINE_COMMENT_MODE,
      hljs2.C_BLOCK_COMMENT_MODE
    ],
    illegal: "\\S"
  };
}
var json_default = json;

// appdrawer/adSandbox.js
core_default.registerLanguage("javascript", javascript_default);
core_default.registerLanguage("json", json_default);
async function openSandbox(element, pageArgs) {
  const sandboxDiv = newSandboxDiv(pageArgs.sandboxDiv);
  sandboxDiv.header_row;
  sandboxDiv.header.append("span").html(
    element.type != "nestedCard" ? `<a href="${sessionStorage.getItem("hostURL")}/?appcard=${element.sandboxJson || element.sandboxHtml}">${element.name}</a>` : element.name
  );
  sandboxDiv.body.style("overflow", "hidden").style("background-color", "white");
  if (element.type == "nestedCard") return openNestedCardSandbox(element, sandboxDiv, pageArgs);
  const res = element.sandboxJson ? await dofetch3(`${pageArgs.app.cardsPath}/${element.sandboxJson}.json`) : await dofetch3(`${pageArgs.app.cardsPath}/${element.sandboxHtml}.txt`);
  if (res.error) {
    sayerror(sandboxDiv.body.insert("div", "div"), res.error);
    return;
  }
  if (element.type == "card") return openCardSandbox(element, res, sandboxDiv, pageArgs);
  if (element.type == "dsButton") return openDatasetButtonSandbox(element, pageArgs, res, sandboxDiv);
}
async function openNestedCardSandbox(nestedCard, sandboxDiv, pageArgs) {
  sandboxDiv.body.style("justify-content", "center").style("background-color", "#f2ebdc");
  const ucList = sandboxDiv.body.append("ul").style("list-style", "none").style("display", "grid").style("grid-template-columns", "40vw 40vw").style("grid-template-rows", "repeat(1, auto)").style("gap", "5px");
  const filteredChildren = nestedCard.children.filter((e) => !e.hidden);
  sandboxDiv.header.trail = new BreadcrumbTrail({
    holder: sandboxDiv.header,
    crumbs: filteredChildren
  });
  filteredChildren.forEach((child) => {
    const uc = ucList.append("li");
    uc.attr("class", "sjpp-app-drawer-card").style("padding", "10px").style("margin", "5px").html(
      `<p style="margin-left: 12px; font-size:14.5px;font-weight:500; display: block;">${child.name}</p>
			<p style="display: block; font-size: 13px; font-weight: 300; margin-left: 20px; justify-content: center; font-style:oblique; color: #403f3f;">${child.description}</p>`
    ).on("click", async (event) => {
      event.stopPropagation();
      ucList.selectAll("*").remove();
      const res = child.sandboxJson ? await dofetch3(`${pageArgs.app.cardsPath}/${child.sandboxJson}.json`) : await dofetch3(`${pageArgs.app.cardsPath}/${child.sandboxHtml}.txt`);
      if (res.error) {
        sayerror(sandboxDiv.body.insert("div", "div"), res.error);
        return;
      }
      if (child.type == "card") {
        sandboxDiv.header.trail.main();
        openCardSandbox(child, res, sandboxDiv, pageArgs);
        const crumbIndex = filteredChildren.findIndex((c) => c == child);
        sandboxDiv.header.trail.update(crumbIndex);
      }
      if (child.type == "dsButton") return openDatasetButtonSandbox(child, pageArgs.app.opts, res, sandboxDiv);
    });
    return JSON.stringify(uc);
  });
}
async function openCardSandbox(card, res, sandboxDiv, pageArgs) {
  if (card.sandboxHtml) {
    const renderHtml = await res.text();
    return sandboxDiv.body.append("div").style("padding", "0vw 0vw 2vw 0vw").append("div").style("background-color", "white").style("margin", "0vw 10vw").style("padding", "10px").append("div").style("margin", "0vw 5vw").html(renderHtml);
  }
  sandboxDiv.body.style("background-color", "white");
  const sandboxArgs = {
    intro: res.intro,
    ppcalls: res.ppcalls.filter((e) => !e.hidden),
    buttons: res.buttons,
    arrowButtons: res.arrowButtons,
    ribbonMessage: res.ribbonMessage,
    citation: res.citation_id
  };
  addHtmlText(sandboxArgs.intro, sandboxDiv.body);
  if (card.ribbon) addHtmlText(sandboxArgs.ribbonMessage, sandboxDiv.body, card.ribbon);
  const mainButtonsDiv = sandboxDiv.body.append("div");
  const mainButtonsContentDiv = sandboxDiv.body.append("div");
  addButtons(sandboxArgs.buttons, mainButtonsDiv);
  addArrowBtns(sandboxArgs, "main", mainButtonsDiv, mainButtonsContentDiv, pageArgs);
  if (card.disableTopTabs) renderContent(sandboxArgs.ppcalls[0], sandboxDiv.body, card, pageArgs);
  else {
    const topTabsDiv = sandboxDiv.body.append("div").style("display", "flex").style("align-content", "end").style("justify-content", "center").style("border", "none").style("border-bottom", "1px solid lightgray").style("width", "100%").style("font-size", "20px");
    const tabsContentDiv = sandboxDiv.body.append("div");
    makeParentTabsMenu(sandboxArgs.ppcalls, card, topTabsDiv, tabsContentDiv, sandboxDiv, pageArgs);
  }
}
function renderContent(ppcalls, div, card, pageArgs) {
  addHtmlText(ppcalls.message, div);
  const buttonsDiv = div.append("div").style("margin-bottom", "20px");
  const buttonsContentDiv = div.append("div");
  addButtons(ppcalls.buttons, buttonsDiv);
  makeDataDownload(ppcalls.download, buttonsDiv, card.section);
  showURLLaunch(ppcalls.urlparam, buttonsDiv, card.section);
  addArrowBtns(ppcalls, "call", buttonsDiv, buttonsContentDiv, pageArgs);
  if (!card.disableTopTabs) {
    div.append("hr").style("border", "0").style("border-top", "1px dashed #e3e3e6").style("width", "100%");
  }
  const runpp_arg = {
    holder: div.append("div").style("margin", "20px").node(),
    /* Do not use window.location.origin
    Will break the embedder (/genomes will be requested from https:/embedder.site.org/genomes, 
    for example). It's very rare for an embedder to want to show this default "portal" header 
    because external portals usually have their own headers, but it will affect simple html 
    pages that embed a runpp() call where the app header is not hidden. */
    host: ppcalls.runargs.host || sessionStorage.getItem("hostURL")
  };
  const callpp = JSON.parse(JSON.stringify(ppcalls.runargs));
  runproteinpaint(Object.assign(runpp_arg, callpp));
}
function makeTopTabs(ppcalls, card, sandboxDiv, pageArgs) {
  const tabs = [];
  const ui = ppcalls.findIndex((t) => t.isUi == true);
  const notui = ppcalls.findIndex((t) => t.isUi == void 0);
  const uiPresent = ui != -1 ? true : false;
  if (uiPresent == true) {
    tabs.push({
      label: "Add Your Data",
      active: false,
      callback: async (event, tab) => {
        try {
          const runpp_arg = {
            holder: tab.contentHolder.append("div").style("margin", "20px").node(),
            sandbox_header: tab.contentHolder,
            host: sessionStorage.getItem("hostURL")
          };
          const callpp = JSON.parse(JSON.stringify(ppcalls[ui].runargs));
          runproteinpaint(Object.assign(runpp_arg, callpp));
          delete tab.callback;
        } catch (e) {
          if (e.stack) console.error(e.stack);
          else throw e;
        }
      }
    });
  }
  if (ppcalls.length == 1 && uiPresent != true || ppcalls.length == 2 && uiPresent == true) {
    tabs.push({
      label: "Example",
      active: false,
      callback: async (event, tab) => {
        try {
          renderContent(ppcalls[notui], tab.contentHolder, card, pageArgs);
          delete tab.callback;
        } catch (e) {
          if (e.stack) console.error(e.stack);
          else throw e;
        }
      }
    });
  }
  if (ppcalls.length > 1 && uiPresent == false || ppcalls.length > 2 && uiPresent == true) {
    tabs.push({
      label: "Examples",
      active: pageArgs?.example ? true : false,
      callback: async (event, tab) => {
        try {
          const examplesOnly = ppcalls.filter((p) => p.isUi != true);
          makeLeftsideTabMenu(card, tab.contentHolder, examplesOnly, sandboxDiv, pageArgs);
          delete tab.callback;
        } catch (e) {
          if (e.stack) console.error(e.stack);
          else throw e;
        }
      }
    });
  }
  return tabs;
}
function makeParentTabsMenu(ppcalls, card, topTabsDiv, tabsContentDiv, sandboxDiv, pageArgs) {
  const tabs = makeTopTabs(ppcalls, card, sandboxDiv, pageArgs);
  new Tabs({ holder: topTabsDiv, contentHolder: tabsContentDiv, tabs }).main();
}
async function makeLeftsideTabMenu(card, contentHolder, examplesOnly, sandboxDiv, pageArgs) {
  const tabs = examplesOnly.map((p, index) => getTabData(p, index, card.section));
  sandboxDiv.header.trail = await new BreadcrumbTrail({
    holder: sandboxDiv.header,
    crumbs: tabs
  });
  function getTabData(ppcalls, i, section) {
    const active = pageArgs?.example ? pageArgs.example.toUpperCase() == ppcalls.label.toUpperCase() : i === 0;
    return {
      active,
      inTrail: active,
      link: `${sessionStorage.getItem("hostURL")}/?appcard=${card.sandboxJson || card.sandboxHtml}&example=${ppcalls.label}`,
      label: ppcalls.label,
      callback: async (event, tab) => {
        const wait = tab_wait(tab.contentHolder);
        try {
          if (!tab.rendered) {
            appear(tab.contentHolder);
            renderContent(ppcalls, tab.contentHolder, section, pageArgs);
            wait.remove();
          }
          tab.rendered = true;
          const crumbIndex = tabs.findIndex((t) => t == tab);
          sandboxDiv.header.trail.update(crumbIndex);
          wait.remove();
        } catch (e) {
          wait.text("Error: " + (e.message || e));
        }
      }
    };
  }
  sandboxDiv.header.trail.main();
  const wrapper = contentHolder.append("div").style("display", "grid").style("grid-template-columns", "minmax(min-content, 10vw) minmax(60vw, 1fr)").classed("sjpp-vertical-tab-menu", true).style("word-break", "break-word");
  const tabsDiv = wrapper.append("div").classed("sjpp-tabs-div", true).style("border-right", "1px solid lightgray");
  const tabsContentDiv = wrapper.append("div").classed("sjpp-content-div", true);
  new Tabs({
    holder: tabsDiv,
    contentHolder: tabsContentDiv,
    tabs,
    linePosition: "right",
    tabsPosition: "vertical",
    gap: "10px"
  }).main();
}
function addHtmlText(text, div, ribbon) {
  if (ribbon && ribbon.expireDate) {
    const today = /* @__PURE__ */ new Date();
    const expire = new Date(ribbon.expireDate);
    if (expire > today && text != void 0 && text) {
      let boldedText2 = function() {
        const str = ribbon.text.toLowerCase();
        return str[0].toUpperCase() + str.slice(1);
      };
      var boldedText = boldedText2;
      div.append("div").style("margin", "20px").html(`<p style="display:inline-block;font-weight:bold">${boldedText2()}: &nbsp</p>${text}`);
    }
  } else if (text != void 0 && text) {
    div.append("div").style("margin", "20px").html(text);
  }
}
function addButtons(buttons, div) {
  if (buttons) {
    buttons.forEach((button) => {
      const sandboxButton = makeButton({ div, text: button.name });
      sandboxButton.on("click", (event) => {
        event.stopPropagation();
        if (button.download) window.open(`${button.download}`, "_self", "download");
        else window.open(`${button.link}`, `${button.name}`);
      });
    });
  }
}
function makeArrowButtons(arrows, btns) {
  if (arrows) {
    arrows.forEach((arrow) => {
      const contents = `<div style="margin:10px;" class="sjpp-arrow-content">
				${arrow.message ? `<div style="margin: 1vw;">${arrow.message}</div>` : ""}
				${arrow.links ? arrow.links.map((hyperlink) => {
        if (!hyperlink) return "";
        if (hyperlink.download) {
          return `<a style="cursor:pointer; margin-left:20px;" onclick="event.stopPropagation();" href="${hyperlink.download}", target="_self" download>${hyperlink.name}</a>`;
        }
        if (hyperlink.link) {
          return `<a style="cursor:pointer; margin-left:20px;" onclick="event.stopPropagation();" href="${hyperlink.link}", target="_blank">${hyperlink.name}</a>`;
        }
      }).join("") : ""}</div>`;
      btns.push({
        name: arrow.name,
        callback: async (rdiv) => {
          try {
            rdiv.append("div").html(contents);
          } catch (e) {
            alert("Error: " + e);
          }
        }
      });
    });
  }
}
async function addArrowBtns(args, type, bdiv, rdiv, pageArgs) {
  let btns = [];
  if (type == "call") showCode(args, btns);
  const genome = args?.runargs?.genome;
  if (args.datapreview && genome) showViewData(btns, args.datapreview, genome);
  if (args.citation || args.data_source) {
    const res = await dofetch3(`/${pageArgs.app.cardsPath}/citations.json`);
    if (res.error) {
      console.error(`Error: ${res.error}`);
      return;
    }
    for (const pub of res.publications) {
      if (args.citation == pub.id || args.data_source == pub.id) {
        const label = args.data_source ? "Data Source" : "Citation";
        showCitation(btns, pub, label);
      }
    }
  }
  makeArrowButtons(args.arrowButtons, btns);
  const active_btn = btns.findIndex((b) => b.active) == -1 ? false : true;
  for (let i = 0; i < btns.length; i++) {
    const btn = btns[i];
    btn.btn = makeButton({ div: bdiv, text: btn.name + " \u25BC" });
    btn.c = rdiv.append("div").style("margin", "20px 0px 10px 20px").style("display", active_btn && i == 0 || btn.active ? "block" : "none");
    if (active_btn && i == 0 && btn.callback || btn.active) {
      btn.callback(btn.c);
      delete btn.callback;
    }
    btn.btn.on("click", () => {
      if (btn.c.style("display") != "none") {
        btn.btn.text(btn.name + " \u25BC").style("color", "black").style("background-color", "#cfe2f3");
        btn.c.style("display", "none");
      } else {
        btn.btn.text(btn.name + " \u25B2").style("color", "whitesmoke").style("background-color", "#487ba8");
        appear(btn.c);
        for (let j = 0; j < btns.length; j++) {
          if (i != j) {
            btns[j].btn.text(btns[j].name + " \u25BC").style("color", "black").style("background-color", "#cfe2f3");
            btns[j].c.style("display", "none");
          }
        }
      }
      if (btn.callback) {
        btn.callback(btn.c);
        delete btn.callback;
      }
    });
  }
}
function showURLLaunch(urlparam, div, section) {
  if (!urlparam) return;
  const URLbtn = makeButton({ div, text: section == "apps" ? "Run app from URL" : "Run track from URL" });
  URLbtn.on("click", (event) => {
    const hostURL = getHostURL();
    event.stopPropagation();
    window.open(`${hostURL}${urlparam}`, "_blank");
  });
}
function makeDataDownload(download, div, section) {
  if (!download) return;
  const dataBtn = makeButton({
    div,
    text: section == "apps" ? "Download App File(s)" : "Download Track File(s)"
  });
  dataBtn.on("click", (event) => {
    event.stopPropagation();
    window.open(`${download}`, "_self", "download");
  });
}
async function showCode(ppcalls, btns) {
  if (ppcalls.isUi == true) return;
  const runppCode = core_default.highlight(
    `runproteinpaint({
    host: "${sessionStorage.getItem("hostURL")}",
    holder: document.getElementById('a'),
    ` + // Fix for first argument not properly appearing underneath holder
    JSON.stringify(ppcalls.runargs, "", 4).replaceAll(/"(.+)"\s*:/g, "$1:").replaceAll(/\\t/g, "	").replaceAll(/\\n/g, "\r	").slice(1, -1).trim() + `\r})`,
    { language: "javascript" }
  ).value;
  const runppContents = `<pre style="border: 1px solid #d7d7d9; align-items: center; justify-content: center; margin: 0px 10px 5px 30px; overflow:auto; max-height:400px; ${ppcalls.jsonpath ? `min-height:400px;` : `min-height: auto;`}">
	<code style="font-size:14px; display:block;">${runppCode}</code></pre>`;
  btns.push({
    name: "Code",
    callback: async (rdiv) => {
      try {
        if (ppcalls.jsonpath) {
          const includeJson = await showJsonCode(ppcalls);
          const runppHeader = "<p style='margin:20px 5px 20px 25px;'>ProteinPaint JS code</p>";
          const grid = rdiv.append("div").style("display", "grid").style("grid-template-columns", "repeat(auto-fit, minmax(100px, 1fr))").style("gap", "5px");
          grid.append("div").style("display", "block").html(runppHeader + runppContents);
          grid.append("div").style("display", "block").html(includeJson);
        } else {
          rdiv.append("div").html(runppContents);
        }
      } catch (e) {
        alert("Error: " + e);
      }
    }
  });
}
async function showJsonCode(ppcalls) {
  const jsondata = await dofetch("textfile", { file: ppcalls.jsonpath });
  const json_code = JSON.parse(jsondata.text);
  const splitpath = ppcalls.jsonpath.split("/");
  const filename = splitpath[splitpath.length - 1];
  let lines = JSON.stringify(json_code, "", 4).split("\n");
  let slicedjson;
  if (lines.length > 120) {
    lines = lines.slice(0, 100);
    slicedjson = true;
  }
  const code = core_default.highlight(lines.join("\n"), { language: "json" }).value;
  const json_contents = `<div>
			<p style="margin: 20px 5px 20px 25px; display: inline-block;">JSON code </p>
			<p style="display: inline-block; color: #696969; font-style:oblique;"> (contents of ${filename})</p>
		</div> 
		<pre style="border: 1px solid #d7d7d9; align-items: center; justify-content: center; margin: 0px 10px 5px 10px; max-height:400px; min-height:400px; overflow:auto;">
			<code class="sjpp-json-code" style="font-size:14px; display:block;">${slicedjson == true ? `${code} ...<br><p style='margin:20px 25px; justify-content:center;'>Showing first 100 lines. To see the entire JSON, download ${filename} from the button above.</p>` : `${code}`}
			</code>
		</pre>`;
  return json_contents;
}
function showCitation(btns, pub, label) {
  btns.push({
    name: label,
    callback: async (rdiv) => {
      try {
        rdiv.append("div").style("margin-left", "5w").html(
          `<span style="display: inline-block;">${pub.title}. <em>${pub.journal}</em>, ${pub.year}.
						${pub.pmid ? ` PMID: <a href="${pub.pmidURL}" target="${pub.pmid}">${pub.pmid}</a>` : ` doi: <a href="${pub.doi}" target="${pub.doi}">${pub.doi}</a>`}</span>`
        );
      } catch (e) {
        alert("Error: " + e);
      }
    }
  });
}
function makeDataPreviewDiv(content, contLength, div, filename, message) {
  div.append("div").html(`
		${message ? `<p style="display:block;">${message}<p>` : ""}
		<p style="display: inline-block;">Data preview <span style="color: #696969; font-style:oblique;"> 
		${contLength > 10 ? `(first ${content.length} rows of ${filename})</span></p>` : `(content of ${filename})</span></p>`} 
	`);
  const bedjContent_div = div.append("div").style("display", "grid").style("grid-template-columns", "1fr").style("max-width", "80%").style("margin-left", "10px").style("border", "1px solid rgb(227, 227, 230)").style("white-space", "pre").style("overflow-x", "scroll").style("opacity", "0.65").style("padding", "1vw");
  content.forEach((c) => {
    bedjContent_div.append("code").html(c);
  });
}
async function showViewData(btns, data, genome) {
  btns.push({
    name: "View Data",
    callback: async (rdiv) => {
      try {
        for (const file of data) {
          const res = await dofetch3("cardsjson", {
            body: { datafile: file.file, genome, tabixCoord: file.tabixQueryCoord }
          });
          if (res.error) {
            console.error(`Error: ${res.error}`);
            rdiv.text(`Error retrieving example data: ${res.error}`);
            return;
          }
          const returnedContent = res.file;
          const contLength = returnedContent.length;
          const content = returnedContent.slice(0, 10);
          const splitpath = file.file.split("/");
          const filename = splitpath[splitpath.length - 1];
          makeDataPreviewDiv(content, contLength, rdiv, filename, file.message);
        }
      } catch (e) {
        alert("Error: " + e);
      }
    }
  });
}
async function openDatasetButtonSandbox(elem, pageArgs, res, sandboxDiv) {
  if (elem.sandboxHtml) {
    const renderHtml = await res.text();
    return sandboxDiv.body.append("div").style("line-height", "1.5em").style("padding", "1.5em 1.5em 2em 1.5em").html(renderHtml);
  }
  const genome = pageArgs?.fromApp ? pageArgs.genomes[res.button.availableGenomes[0]] : pageArgs.app.opts.genomes[res.button.availableGenomes[0]];
  let genomes;
  if (res.button.runargs.host) {
    genomes = await getGenomes(res.button.runargs.host);
  } else genomes = pageArgs?.fromApp ? pageArgs.genomes : pageArgs.app.opts.genomes;
  const par = {
    // First genome in .availableGenomes is the default
    availableGenomes: res.button.availableGenomes,
    genome,
    intro: res.button.intro,
    name: res.button.name,
    runargs: res.button.runargs,
    searchBar: res.button.searchBar,
    dsURLparam: res.button.dsURLparam,
    citation: res.citation_id
  };
  const mainDiv = sandboxDiv.body.append("div").style("padding", "1em").style("border-bottom", "1px solid #d0e3ff");
  if (par.citation) {
    const buttonsDiv = mainDiv.append("div").style("margin-bottom", "20px");
    const buttonsContentDiv = mainDiv.append("div");
    await addArrowBtns(par, "main", buttonsDiv, buttonsContentDiv, pageArgs);
  }
  if (par.intro) {
    mainDiv.append("div").style("line-height", "1.5em").style("padding", "0.5em 0.5em 1em 0.5em").html(par.intro);
  }
  if (par.searchBar == "none") {
    const originalURL = sessionStorage.getItem("hostURL");
    const runppArg = {
      holder: sandboxDiv.body.append("div").style("margin", "20px").style("overflow-x", "auto").node(),
      host: par.runargs.host || originalURL
    };
    const callpp = JSON.parse(JSON.stringify(par.runargs));
    await runproteinpaint(Object.assign(runppArg, callpp));
    if (originalURL != sessionStorage.getItem("hostURL")) sessionStorage.setItem("hostURL", originalURL);
    return;
  }
  if (par.availableGenomes.length > 1) addDatasetGenomeBtns(mainDiv, genomes);
  else {
    mainDiv.append("div").style("display", "inline-block").style("margin-left", "20px").style("color", "rgb(117, 115, 115)").text(par.availableGenomes[0]);
  }
  const searchBarDiv = mainDiv.append("div").style("display", "inline-block").style("padding", "0.5em");
  const allResultsDiv = sandboxDiv.body.append("div").style("max-width", "90vw");
  const coords = addGeneSearchbox({
    genome: par.genome,
    tip: new Menu({ padding: "" }),
    row: searchBarDiv,
    searchOnly: par.searchBar == "gene" ? "gene" : "",
    focusOff: true,
    callback: async (div) => {
      const resultDiv = allResultsDiv.insert("div", ":first-child").style("max-width", "90vw").style("margin", "1vw");
      resultDiv.append("div").style("display", "inline-block").style("cursor", "default").style("margin", "0px").style("font-size", "1.5em").html("&times;").on("click", () => {
        resultDiv.selectAll("*").remove();
      });
      makeURLbutton(resultDiv, coords, par);
      const runppArg = {
        holder: resultDiv.append("div").style("margin", "20px").node(),
        host: sessionStorage.getItem("hostURL"),
        genome: par.genome.name
      };
      par.runargs.block == true ? (runppArg.position = `${coords.chr}:${coords.start}-${coords.stop}`) && (runppArg.nativetracks = "Refgene") : runppArg.gene = coords.geneSymbol;
      const callpp = JSON.parse(JSON.stringify(par.runargs));
      runproteinpaint(Object.assign(runppArg, callpp));
    }
  });
  function addDatasetGenomeBtns(div, genomes2) {
    div.append("div").style("display", "inline-block").style("padding", "10px 10px 0px 20px");
    const btns = [];
    par.availableGenomes.forEach((genome2) => {
      btns.push({
        label: genome2,
        callback: (event, tab) => {
          par.genome = genomes2[genome2];
        }
      });
    });
    new Tabs({ holder: div, tabs: btns, noContent: true }).main();
  }
}
function makeURLbutton(div, coords, par) {
  const URLbtn = makeButton({ div, text: "Run Result from URL" });
  const blockOn = par.runargs.block == true ? `position=${coords.chr}:${coords.start}-${coords.stop}` : `gene=${coords.geneSymbol}`;
  URLbtn.on("click", (event) => {
    event.stopPropagation();
    const hostURL = getHostURL();
    window.open(`${hostURL}/?genome=${par.genome.name}&${blockOn}&${par.dsURLparam}`, "_blank");
  });
}
function getHostURL() {
  const hostURL = sessionStorage.getItem("hostURL");
  if (hostURL.startsWith("http://localhost") || hostURL.startsWith("https://pp")) {
    return hostURL;
  } else return "https://proteinpaint.stjude.org";
}
async function getGenomes(host) {
  const genomeURL = `${host}/genomes?embedder=${sessionStorage.getItem("hostURL").replace(/^https?:\/\//, "")}`;
  try {
    const response = await fetch(genomeURL);
    if (!response.ok) throw new Error(`HTTP Response error for genomes url ${response.status}`);
    const data = await response.json();
    return data;
  } catch (e) {
    console.error(`Error fetching genomes: ${e} from ${genomeURL}`);
    return null;
  }
}

export {
  makeButton,
  openSandbox
};
//# sourceMappingURL=chunk-R2MMURGK.js.map
