free-pi-cli 0.4.5 → 0.4.7

package/dist/{main-r61kpjqw.js → main-ep5298x9.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { realpathSync } from "node:fs";
-import { dirname as dirname5, join as join5 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { realpathSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname5, join as join6 } from "node:path";
 
 // src/browser.ts
 import { spawn } from "node:child_process";
@@ -45,7 +46,7 @@ function openBrowser(url, platform = process.platform, spawnImpl = spawn) {
 // package.json
 var package_default = {
   name: "free-pi-cli",
-  version: "0.4.5",
+  version: "0.4.7",
   description: "Free, ad-supported distribution of the pi coding agent. Inference paid for by ads.",
   license: "MIT",
   type: "module",
@@ -5238,6 +5239,2585 @@ async function fetchMe(deps) {
 
 // ../pi-ads/src/style.ts
 import { createHash as createHash2 } from "node:crypto";
+
+// ../../node_modules/.bun/marked@18.0.11/node_modules/marked/lib/marked.esm.js
+function A() {
+  return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
+}
+var R = A();
+function j(l) {
+  R = l;
+}
+var z = { exec: () => null };
+function I(l) {
+  let e = [];
+  return (t) => {
+    let n = Math.max(0, Math.min(3, t - 1)), s = e[n];
+    return s || (s = l(n), e[n] = s), s;
+  };
+}
+function k(l, e = "") {
+  let t = typeof l == "string" ? l : l.source, n = { replace: (s, r) => {
+    let i = typeof r == "string" ? r : r.source;
+    return i = i.replace(m.caret, "$1"), t = t.replace(s, i), n;
+  }, getRegex: () => new RegExp(t, e) };
+  return n;
+}
+var Oe = ((l = "") => {
+  try {
+    return !!new RegExp("(?<=1)(?<!1)" + l);
+  } catch {
+    return false;
+  }
+})();
+var m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (l) => new RegExp(`^( {0,3}${l})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: I((l) => new RegExp(`^ {0,${l}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`)), hrRegex: I((l) => new RegExp(`^ {0,${l}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`)), fencesBeginRegex: I((l) => new RegExp(`^ {0,${l}}(?:\`\`\`|~~~)`)), headingBeginRegex: I((l) => new RegExp(`^ {0,${l}}#`)), htmlBeginRegex: I((l) => new RegExp(`^ {0,${l}}<(?:[a-z].*>|!--)`, "i")), blockquoteBeginRegex: I((l) => new RegExp(`^ {0,${l}}>`)) };
+var Te = /^(?:[ \t]*(?:\n|$))+/;
+var we = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+var ye = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+var q = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+var Pe = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+var U = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
+var oe = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+var ae = k(oe).replace(/bull/g, U).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+var Se = k(oe).replace(/bull/g, U).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+var K = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table|[ \t]+\n)[^\n]+)*)/;
+var _e = /^[^\n]+/;
+var W = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
+var $e = k(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", W).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+var Le = k(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g, U).getRegex();
+var Q = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var X = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+var Ee = k("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n*|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>[^\\n]*\\n*|$)|<![A-Z][\\s\\S]*?(?:>[^\\n]*\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>[^\\n]*\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$))", "i").replace("comment", X).replace("tag", Q).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+var le = (l) => k(K).replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", l).replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex();
+var ze = le(/ {0,3}(?:[*+-]|1[.)])[ \t]+[^ \t\n]/);
+var Me = le(/ {0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]|\n|$)/);
+var Ae = k(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", Me).getRegex();
+var J = { blockquote: Ae, code: we, def: $e, fences: ye, heading: Pe, hr: q, html: Ee, lheading: ae, list: Le, newline: Te, paragraph: ze, table: z, text: _e };
+var se = k("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}\t)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex();
+var Ie = { ...J, lheading: Se, table: se, paragraph: k(K).replace("hr", q).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", se).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", Q).getRegex() };
+var Ce = { ...J, html: k(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", X).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: z, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: k(K).replace("hr", q).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", ae).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
+var Be = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+var De = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+var ue = /^( {2,}|\\)\n(?!\s*$)/;
+var qe = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+var _ = /[\p{P}\p{S}]/u;
+var C = /[\s\p{P}\p{S}]/u;
+var v = /[^\s\p{P}\p{S}]/u;
+var ve = k(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, C).getRegex();
+var He = /[\p{Pi}\p{Ps}"']/u;
+var pe = /(?!~)[\p{P}\p{S}]/u;
+var Ze = /(?!~)[\s\p{P}\p{S}]/u;
+var Ge = /(?:[^\s\p{P}\p{S}]|~)/u;
+var Qe = k(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", Oe ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
+var ce = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/;
+var Ne = k(ce, "u").replace(/punct/g, _).getRegex();
+var je = k(ce, "u").replace(/punct/g, pe).getRegex();
+var Fe = /^(?:\*+(?:((?!\*)(?!openQuote)punct)|([^\s*]))?)|^_+(?:((?!_)(?!openQuote)punct)|([^\s_]))?/;
+var Ue = k(Fe, "u").replace(/openQuote/g, He).replace(/punct/g, _).getRegex();
+var he = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)";
+var Ke = k(he, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var We = k(he, "gu").replace(/notPunctSpace/g, Ge).replace(/punctSpace/g, Ze).replace(/punct/g, pe).getRegex();
+var Xe = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)[\\s](\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|(?:(?!\\*)punct|notPunctSpace)(\\*+)(?!\\*)(?=notPunctSpace)";
+var Je = k(Xe, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var Ve = k("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var Ye = "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)[\\s](_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)|(?:(?!_)punct|notPunctSpace)(_+)(?!_)(?=notPunctSpace)";
+var et = k(Ye, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var tt = k(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, _).getRegex();
+var nt = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)";
+var rt = k(nt, "gu").replace(/notPunctSpace/g, v).replace(/punctSpace/g, C).replace(/punct/g, _).getRegex();
+var st = k(/\\(punct)/, "gu").replace(/punct/g, _).getRegex();
+var it = k(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+var ot = k(X).replace("(?:-->|$)", "-->").getRegex();
+var at = k("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", ot).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+var G = /(?:\[(?:\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/;
+var lt = k(/^!?\[(label)\]\(\s*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?\s*\)/).replace("label", G).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]+|(?=\))/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+var ke = k(/^!?\[(label)\]\[(ref)\]/).replace("label", G).replace("ref", W).getRegex();
+var de = k(/^!?\[(ref)\](?:\[\])?/).replace("ref", W).getRegex();
+var ut = k("reflink|nolink(?!\\()", "g").replace("reflink", ke).replace("nolink", de).getRegex();
+var ie = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
+var V = { _backpedal: z, anyPunctuation: st, autolink: it, blockSkip: Qe, br: ue, code: De, del: z, delLDelim: z, delRDelim: z, emStrongLDelim: Ne, emStrongRDelimAst: Ke, emStrongRDelimUnd: Ve, escape: Be, link: lt, nolink: de, punctuation: ve, reflink: ke, reflinkSearch: ut, tag: at, text: qe, url: z };
+var pt = { ...V, emStrongLDelim: Ue, emStrongRDelimAst: Je, emStrongRDelimUnd: et, link: k(/^!?\[(label)\]\((.*?)\)/).replace("label", G).getRegex(), reflink: k(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", G).getRegex() };
+var F = { ...V, emStrongRDelimAst: We, emStrongLDelim: je, delLDelim: tt, delRDelim: rt, url: k(/^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("protocol", ie).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: k(/^(`+|~+|[^`~])(?:(?=[`~])|(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/).replace("protocol", ie).getRegex() };
+var ct = { ...F, br: k(ue).replace("{2,}", "*").getRegex(), text: k(F.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
+var H = { normal: J, gfm: Ie, pedantic: Ce };
+var B = { normal: V, gfm: F, breaks: ct, pedantic: pt };
+var ht = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+var ge = (l) => ht[l];
+function T(l, e) {
+  if (e) {
+    if (m.escapeTest.test(l))
+      return l.replace(m.escapeReplace, ge);
+  } else if (m.escapeTestNoEncode.test(l))
+    return l.replace(m.escapeReplaceNoEncode, ge);
+  return l;
+}
+function Y(l) {
+  try {
+    l = encodeURI(l).replace(m.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return l;
+}
+function ee(l, e) {
+  let t = l.replace(m.findPipe, (r, i, o) => {
+    let u = false, a = i;
+    for (;--a >= 0 && o[a] === "\\"; )
+      u = !u;
+    return u ? "|" : " |";
+  }), n = t.split(m.splitPipe), s = 0;
+  if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e)
+    if (n.length > e)
+      n.splice(e);
+    else
+      for (;n.length < e; )
+        n.push("");
+  for (;s < n.length; s++)
+    n[s] = n[s].trim().replace(m.slashPipe, "|");
+  return n;
+}
+function $(l, e, t) {
+  let n = l.length;
+  if (n === 0)
+    return "";
+  let s = 0;
+  for (;s < n; ) {
+    let r = l.charAt(n - s - 1);
+    if (r === e && !t)
+      s++;
+    else if (r !== e && t)
+      s++;
+    else
+      break;
+  }
+  return l.slice(0, n - s);
+}
+function te(l) {
+  let e = l.split(`
+`), t = e.length - 1;
+  for (;t >= 0 && m.blankLine.test(e[t]); )
+    t--;
+  return e.length - t <= 2 ? l : e.slice(0, t + 1).join(`
+`);
+}
+function fe(l, e) {
+  if (l.indexOf(e[1]) === -1)
+    return -1;
+  let t = 0;
+  for (let n = 0;n < l.length; n++)
+    if (l[n] === "\\")
+      n++;
+    else if (l[n] === e[0])
+      t++;
+    else if (l[n] === e[1] && (t--, t < 0))
+      return n;
+  return t > 0 ? -2 : -1;
+}
+function me(l, e = 0) {
+  let t = e, n = "";
+  for (let s of l)
+    if (s === "\t") {
+      let r = 4 - t % 4;
+      n += " ".repeat(r), t += r;
+    } else
+      n += s, t++;
+  return n;
+}
+function xe(l, e, t, n, s) {
+  let r = e.href, i = e.title || null, o = l[1].replace(s.other.outputLinkReplace, "$1"), u = l[0].charAt(0) === "!";
+  n.state.inLink = true;
+  let a = n.state.linkEmitted, p = n.state.inRawBlock;
+  n.state.linkEmitted = false;
+  let c = n.inlineTokens(o), h = n.state.linkEmitted;
+  if (n.state.linkEmitted = a, n.state.inLink = false, !u) {
+    if (h) {
+      n.state.inRawBlock = p;
+      return;
+    }
+    n.state.linkEmitted = true;
+  }
+  return { type: u ? "image" : "link", raw: t, href: r, title: i, text: o, tokens: c };
+}
+function kt(l, e, t) {
+  let n = l.match(t.other.indentCodeCompensation);
+  if (n === null)
+    return e;
+  let s = n[1];
+  return e.split(`
+`).map((r) => {
+    let i = r.match(t.other.beginningSpace);
+    if (i === null)
+      return r;
+    let [o] = i;
+    return o.length >= s.length ? r.slice(s.length) : r;
+  }).join(`
+`);
+}
+var y = class {
+  options;
+  rules;
+  lexer;
+  constructor(e) {
+    this.options = e || R;
+  }
+  space(e) {
+    let t = this.rules.block.newline.exec(e);
+    if (t && t[0].length > 0)
+      return { type: "space", raw: t[0] };
+  }
+  code(e) {
+    let t = this.rules.block.code.exec(e);
+    if (t) {
+      let n = this.options.pedantic ? t[0] : te(t[0]), s = n.replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: n, codeBlockStyle: "indented", text: s };
+    }
+  }
+  fences(e) {
+    let t = this.rules.block.fences.exec(e);
+    if (t) {
+      let n = t[0], s = kt(n, t[3] || "", this.rules);
+      return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: s };
+    }
+  }
+  heading(e) {
+    let t = this.rules.block.heading.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let s = $(n, "#");
+        (this.options.pedantic || !s || this.rules.other.endingSpaceChar.test(s)) && (n = s.trim());
+      }
+      return { type: "heading", raw: $(t[0], `
+`), depth: t[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(e) {
+    let t = this.rules.block.hr.exec(e);
+    if (t)
+      return { type: "hr", raw: $(t[0], `
+`) };
+  }
+  blockquote(e) {
+    let t = this.rules.block.blockquote.exec(e);
+    if (t) {
+      let n = $(t[0], `
+`).split(`
+`), s = "", r = "", i = [];
+      for (;n.length > 0; ) {
+        let o = false, u = [], a;
+        for (a = 0;a < n.length; a++)
+          if (this.rules.other.blockquoteStart.test(n[a]))
+            u.push(n[a]), o = true;
+          else if (!o)
+            u.push(n[a]);
+          else
+            break;
+        n = n.slice(a);
+        let p = u.join(`
+`), c = p.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        s = s ? `${s}
+${p}` : p, r = r ? `${r}
+${c}` : c;
+        let h = this.lexer.state.top;
+        if (this.lexer.state.top = true, this.lexer.blockTokens(c, i, true), this.lexer.state.top = h, n.length === 0)
+          break;
+        let d = i.at(-1);
+        if (d?.type === "code")
+          break;
+        if (d?.type === "blockquote") {
+          let O = d, g = n.join(`
+`), w = O.raw + `
+` + g.replace(this.rules.other.blockquoteSetextReplace2, ""), E = this.blockquote(w);
+          i[i.length - 1] = E, s = `${s}
+${g}`, r = r.substring(0, r.length - O.text.length) + E.text;
+          break;
+        } else if (d?.type === "list") {
+          let O = d, g = O.raw + `
+` + n.join(`
+`), w = this.list(g);
+          i[i.length - 1] = w, s = s.substring(0, s.length - d.raw.length) + w.raw, r = r.substring(0, r.length - O.raw.length) + w.raw, n = g.substring(i.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: s, tokens: i, text: r };
+    }
+  }
+  list(e) {
+    let t = this.rules.block.list.exec(e);
+    if (t) {
+      let n = t[1].trim(), s = n.length > 1, r = { type: "list", raw: "", ordered: s, start: s ? +n.slice(0, -1) : "", loose: false, items: [] };
+      n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]");
+      let i = this.rules.other.listItemRegex(n), o = false;
+      for (;e; ) {
+        let a = false, p = "", c = "";
+        if (!(t = i.exec(e)) || this.rules.block.hr.test(e))
+          break;
+        p = t[0], e = e.substring(p.length);
+        let h = me(t[2].split(`
+`, 1)[0], t[1].length), d = e.split(`
+`, 1)[0], O = !h.trim(), g = 0;
+        if (this.options.pedantic ? (g = 2, c = h.trimStart()) : O ? g = t[1].length + 1 : (g = h.search(this.rules.other.nonSpaceChar), g = g > 4 ? 1 : g, c = h.slice(g), g += t[1].length), O && this.rules.other.blankLine.test(d) && (p += d + `
+`, e = e.substring(d.length + 1), a = true), !a) {
+          let w = this.rules.other.nextBulletRegex(g), E = this.rules.other.hrRegex(g), ne = this.rules.other.fencesBeginRegex(g), re = this.rules.other.headingBeginRegex(g), be = this.rules.other.htmlBeginRegex(g), Re = this.rules.other.blockquoteBeginRegex(g);
+          for (;e; ) {
+            let N = e.split(`
+`, 1)[0], D;
+            if (d = N, this.options.pedantic ? (d = d.replace(this.rules.other.listReplaceNesting, "  "), D = d) : D = d.replace(this.rules.other.tabCharGlobal, "    "), ne.test(d) || re.test(d) || be.test(d) || Re.test(d) || w.test(d) || E.test(d))
+              break;
+            if (D.search(this.rules.other.nonSpaceChar) >= g || !d.trim())
+              c += `
+` + D.slice(g);
+            else {
+              if (O || h.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || ne.test(h) || re.test(h) || E.test(h))
+                break;
+              c += `
+` + d;
+            }
+            O = !d.trim(), p += N + `
+`, e = e.substring(N.length + 1), h = D.slice(g);
+          }
+        }
+        r.loose || (o ? r.loose = true : this.rules.other.doubleBlankLine.test(p) && (o = true)), r.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), r.raw += p;
+      }
+      let u = r.items.at(-1);
+      if (u)
+        u.raw = u.raw.trimEnd(), u.text = u.text.trimEnd();
+      else
+        return;
+      r.raw = r.raw.trimEnd();
+      for (let a of r.items)
+        if (this.lexer.state.top = false, a.tokens = this.lexer.blockTokens(a.text, []), !r.loose) {
+          let p = a.tokens.filter((h) => h.type === "space"), c = p.length > 0 && p.some((h) => this.rules.other.anyLine.test(h.raw));
+          r.loose = c;
+        }
+      for (let a of r.items) {
+        let p = a.tokens[0];
+        if (a.task && (p?.type === "text" || p?.type === "paragraph")) {
+          a.text = a.text.replace(this.rules.other.listReplaceTask, ""), p.raw = p.raw.replace(this.rules.other.listReplaceTask, ""), p.text = p.text.replace(this.rules.other.listReplaceTask, "");
+          for (let h = this.lexer.inlineQueue.length - 1;h >= 0; h--)
+            if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[h].src)) {
+              this.lexer.inlineQueue[h].src = this.lexer.inlineQueue[h].src.replace(this.rules.other.listReplaceTask, "");
+              break;
+            }
+          let c = this.rules.other.listTaskCheckbox.exec(a.raw);
+          if (c) {
+            let h = { type: "checkbox", raw: c[0] + " ", checked: c[0] !== "[ ]" };
+            a.checked = h.checked, r.loose ? a.tokens[0] && ["paragraph", "text"].includes(a.tokens[0].type) && "tokens" in a.tokens[0] && a.tokens[0].tokens ? (a.tokens[0].raw = h.raw + a.tokens[0].raw, a.tokens[0].text = h.raw + a.tokens[0].text, a.tokens[0].tokens.unshift(h)) : a.tokens.unshift({ type: "paragraph", raw: h.raw, text: h.raw, tokens: [h] }) : a.tokens.unshift(h);
+          }
+        } else
+          a.task && (a.task = false);
+      }
+      if (r.loose)
+        for (let a of r.items) {
+          a.loose = true;
+          for (let p of a.tokens)
+            p.type === "text" && (p.type = "paragraph");
+        }
+      return r;
+    }
+  }
+  html(e) {
+    let t = this.rules.block.html.exec(e);
+    if (t) {
+      let n = te(t[0]);
+      return { type: "html", block: true, raw: n, pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: n };
+    }
+  }
+  def(e) {
+    let t = this.rules.block.def.exec(e);
+    if (t) {
+      let n = t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal, " "), s = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
+      return { type: "def", tag: n, raw: $(t[0], `
+`), href: s, title: r };
+    }
+  }
+  table(e) {
+    let t = this.rules.block.table.exec(e);
+    if (!t || !this.rules.other.tableDelimiter.test(t[2]))
+      return;
+    let n = ee(t[1]), s = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], i = { type: "table", raw: $(t[0], `
+`), header: [], align: [], rows: [] };
+    if (n.length === s.length) {
+      for (let o of s)
+        this.rules.other.tableAlignRight.test(o) ? i.align.push("right") : this.rules.other.tableAlignCenter.test(o) ? i.align.push("center") : this.rules.other.tableAlignLeft.test(o) ? i.align.push("left") : i.align.push(null);
+      for (let o = 0;o < n.length; o++)
+        i.header.push({ text: n[o], tokens: this.lexer.inline(n[o]), header: true, align: i.align[o] });
+      for (let o of r)
+        i.rows.push(ee(o, i.header.length).map((u, a) => ({ text: u, tokens: this.lexer.inline(u), header: false, align: i.align[a] })));
+      return i;
+    }
+  }
+  lheading(e) {
+    let t = this.rules.block.lheading.exec(e);
+    if (t) {
+      let n = t[1].trim();
+      return { type: "heading", raw: $(t[0], `
+`), depth: t[2].charAt(0) === "=" ? 1 : 2, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  paragraph(e) {
+    let t = this.rules.block.paragraph.exec(e);
+    if (t) {
+      let n = t[1].charAt(t[1].length - 1) === `
+` ? t[1].slice(0, -1) : t[1];
+      return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(e) {
+    let t = this.rules.block.text.exec(e);
+    if (t)
+      return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) };
+  }
+  escape(e) {
+    let t = this.rules.inline.escape.exec(e);
+    if (t)
+      return { type: "escape", raw: t[0], text: t[1] };
+  }
+  tag(e) {
+    let t = this.rules.inline.tag.exec(e);
+    if (t)
+      return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] };
+  }
+  link(e) {
+    let t = this.rules.inline.link.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(n)) {
+        if (!this.rules.other.endAngleBracket.test(n))
+          return;
+        let i = $(n.slice(0, -1), "\\");
+        if ((n.length - i.length) % 2 === 0)
+          return;
+      } else {
+        let i = fe(t[2], "()");
+        if (i === -2)
+          return;
+        if (i > -1) {
+          let u = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + i;
+          t[2] = t[2].substring(0, i), t[0] = t[0].substring(0, u).trim(), t[3] = "";
+        }
+      }
+      let s = t[2], r = "";
+      if (this.options.pedantic) {
+        let i = this.rules.other.pedanticHrefTitle.exec(s);
+        i && (s = i[1], r = i[3]);
+      } else
+        r = t[3] ? t[3].slice(1, -1) : "";
+      return s = s.trim(), this.rules.other.startAngleBracket.test(s) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(n) ? s = s.slice(1) : s = s.slice(1, -1)), xe(t, { href: s && s.replace(this.rules.inline.anyPunctuation, "$1"), title: r && r.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules);
+    }
+  }
+  reflink(e, t) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
+      let s = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), r = t[s.toLowerCase()];
+      if (!r) {
+        let i = n[0].charAt(0);
+        return { type: "text", raw: i, text: i };
+      }
+      return xe(n, r, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(e, t, n = "") {
+    let s = this.rules.inline.emStrongLDelim.exec(e);
+    if (!s || !s[1] && !s[2] && !s[3] && !s[4] || s[4] && n.match(this.rules.other.unicodeAlphaNumeric))
+      return;
+    if (!(s[1] || s[3] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let i = [...s[0]].length - 1, o, u, a = i, p = 0, c = s[0][0], h = n === c, d = c === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (d.lastIndex = 0, t = t.slice(-1 * e.length + i);(s = d.exec(t)) !== null; ) {
+        if (o = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !o)
+          continue;
+        if (u = [...o].length, s[3] || s[4]) {
+          a += u;
+          continue;
+        } else if (s[5] || s[6]) {
+          if (i % 3 && !((i + u) % 3)) {
+            p += u;
+            continue;
+          }
+          if (h)
+            break;
+        }
+        if (a -= u, a > 0)
+          continue;
+        u = Math.min(u, u + a + p);
+        let O = [...s[0]][0].length, g = e.slice(0, i + s.index + O + u);
+        if (Math.min(i, u) % 2) {
+          let E = g.slice(1, -1);
+          return { type: "em", raw: g, text: E, tokens: this.lexer.inlineTokens(E) };
+        }
+        let w = g.slice(2, -2);
+        return { type: "strong", raw: g, text: w, tokens: this.lexer.inlineTokens(w) };
+      }
+    }
+  }
+  codespan(e) {
+    let t = this.rules.inline.code.exec(e);
+    if (t) {
+      let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), s = this.rules.other.nonSpaceChar.test(n), r = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return s && r && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n };
+    }
+  }
+  br(e) {
+    let t = this.rules.inline.br.exec(e);
+    if (t)
+      return { type: "br", raw: t[0] };
+  }
+  del(e, t, n = "") {
+    let s = this.rules.inline.delLDelim.exec(e);
+    if (!s)
+      return;
+    if (!(s[1] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let i = [...s[0]].length - 1, o, u, a = i, p = this.rules.inline.delRDelim;
+      for (p.lastIndex = 0, t = t.slice(-1 * e.length + i);(s = p.exec(t)) !== null; ) {
+        if (o = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !o || (u = [...o].length, u !== i))
+          continue;
+        if (s[3] || s[4]) {
+          a += u;
+          continue;
+        }
+        if (a -= u, a > 0)
+          continue;
+        u = Math.min(u, u + a);
+        let c = [...s[0]][0].length, h = e.slice(0, i + s.index + c + u), d = h.slice(i, -i);
+        return { type: "del", raw: h, text: d, tokens: this.lexer.inlineTokens(d) };
+      }
+    }
+  }
+  autolink(e) {
+    let t = this.rules.inline.autolink.exec(e);
+    if (t) {
+      let n, s;
+      return t[2] === "@" ? (n = t[1], s = "mailto:" + n) : (n = t[1], s = n), { type: "link", raw: t[0], text: n, href: s, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(e) {
+    let t;
+    if (t = this.rules.inline.url.exec(e)) {
+      let n, s;
+      if (t[2] === "@")
+        n = t[0], s = "mailto:" + n;
+      else {
+        let r;
+        do
+          r = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? "";
+        while (r !== t[0]);
+        n = t[0], t[1] === "www." ? s = "http://" + t[0] : s = t[0];
+      }
+      return { type: "link", raw: t[0], text: n, href: s, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(e) {
+    let t = this.rules.inline.text.exec(e);
+    if (t) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: t[0], text: t[0], escaped: n };
+    }
+  }
+};
+var x = class l {
+  tokens;
+  options;
+  state;
+  inlineQueue;
+  tokenizer;
+  constructor(e) {
+    this.tokens = [], this.tokens.links = Object.create(null), this.options = e || R, this.options.tokenizer = this.options.tokenizer || new y, this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, linkEmitted: false, top: true };
+    let t = { other: m, block: H.normal, inline: B.normal };
+    this.options.pedantic ? (t.block = H.pedantic, t.inline = B.pedantic) : this.options.gfm && (t.block = H.gfm, this.options.breaks ? t.inline = B.breaks : t.inline = B.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: H, inline: B };
+  }
+  static lex(e, t) {
+    return new l(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new l(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(m.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0;t < this.inlineQueue.length; t++) {
+      let n = this.inlineQueue[t];
+      this.inlineTokens(n.src, n.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], n = false) {
+    this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(m.tabCharGlobal, "    ").replace(m.spaceLine, ""));
+    let s = 1 / 0;
+    for (;e; ) {
+      if (e.length < s)
+        s = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      let r;
+      if (this.options.extensions?.block?.some((o) => (r = o.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false))
+        continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let o = t.at(-1);
+        r.raw.length === 1 && o !== undefined ? o.raw += `
+` : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let o = t.at(-1);
+        o?.type === "paragraph" || o?.type === "text" ? (o.raw += (o.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, o.text += `
+` + r.text, this.inlineQueue.at(-1).src = o.text) : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let o = t.at(-1);
+        o?.type === "paragraph" || o?.type === "text" ? (o.raw += (o.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, o.text += `
+` + r.raw, this.inlineQueue.at(-1).src = o.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      let i = e;
+      if (this.options.extensions?.startBlock) {
+        let o = 1 / 0, u = e.slice(1), a;
+        this.options.extensions.startBlock.forEach((p) => {
+          a = p.call({ lexer: this }, u), typeof a == "number" && a >= 0 && (o = Math.min(o, a));
+        }), o < 1 / 0 && o >= 0 && (i = e.substring(0, o + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(i))) {
+        let o = t.at(-1);
+        n && o?.type === "paragraph" ? (o.raw += (o.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, o.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o.text) : t.push(r), n = i.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let o = t.at(-1);
+        o?.type === "text" ? (o.raw += (o.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, o.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = o.text) : t.push(r);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return this.state.top = true, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  linkInText(e) {
+    if (!e.includes("["))
+      return false;
+    let t = this.tokenizer.rules.inline.link;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.blockSkip))
+      if (t.test(n[0]) && e.charAt(n.index - 1) !== "!")
+        return true;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.reflinkSearch)) {
+      let s = n[0], r = s.lastIndexOf("[");
+      if (!(s.charAt(0) === "!" || !Object.hasOwn(this.tokens.links, s.slice(r + 1, -1))) && !(r > 1 && this.linkInText(s.slice(1, r - 1))))
+        return true;
+    }
+    return false;
+  }
+  inlineTokens(e, t = []) {
+    this.tokenizer.lexer = this;
+    let n = e;
+    if (this.tokens.links && e.includes("[")) {
+      let o = this.tokenizer.rules.inline.reflinkSearch, u = (a) => {
+        let p = a.lastIndexOf("[");
+        if (!Object.hasOwn(this.tokens.links, a.slice(p + 1, -1)))
+          return a;
+        if (p > 1 && a.charAt(0) !== "!") {
+          let c = a.slice(1, p - 1);
+          if (this.linkInText(c))
+            return "[" + c.replace(o, u) + "][" + "a".repeat(a.length - p - 2) + "]";
+        }
+        return "[" + "a".repeat(a.length - 2) + "]";
+      };
+      n = n.replace(o, u);
+    }
+    n = n.replace(this.tokenizer.rules.inline.anyPunctuation, (o) => "+".repeat(o.length)), n = n.replace(this.tokenizer.rules.inline.blockSkip, (o, u, a) => {
+      let p = a ? a.length : 0;
+      return o.slice(0, p) + "[" + "a".repeat(o.length - p - 2) + "]";
+    }), n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
+    let s = false, r = "", i = 1 / 0;
+    for (;e; ) {
+      if (e.length < i)
+        i = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      s || (r = ""), s = false;
+      let o;
+      if (this.options.extensions?.inline?.some((a) => (o = a.call({ lexer: this }, e, t)) ? (e = e.substring(o.raw.length), t.push(o), true) : false))
+        continue;
+      if (o = this.tokenizer.escape(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.tag(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.link(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(o.raw.length);
+        let a = t.at(-1);
+        o.type === "text" && a?.type === "text" ? (a.raw += o.raw, a.text += o.text) : t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.emStrong(e, n, r)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.codespan(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.br(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.del(e, n, r)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (o = this.tokenizer.autolink(e)) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      if (!this.state.inLink && (o = this.tokenizer.url(e))) {
+        e = e.substring(o.raw.length), t.push(o);
+        continue;
+      }
+      let u = e;
+      if (this.options.extensions?.startInline) {
+        let a = 1 / 0, p = e.slice(1), c;
+        this.options.extensions.startInline.forEach((h) => {
+          c = h.call({ lexer: this }, p), typeof c == "number" && c >= 0 && (a = Math.min(a, c));
+        }), a < 1 / 0 && a >= 0 && (u = e.substring(0, a + 1));
+      }
+      if (o = this.tokenizer.inlineText(u)) {
+        e = e.substring(o.raw.length), o.raw.slice(-1) !== "_" && (r = o.raw.slice(-1)), s = true;
+        let a = t.at(-1);
+        a?.type === "text" ? (a.raw += o.raw, a.text += o.text) : t.push(o);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return t;
+  }
+  infiniteLoopError(e) {
+    let t = "Infinite loop on byte: " + e;
+    if (this.options.silent)
+      console.error(t);
+    else
+      throw new Error(t);
+  }
+};
+var P = class {
+  options;
+  parser;
+  constructor(e) {
+    this.options = e || R;
+  }
+  space(e) {
+    return "";
+  }
+  code({ text: e, lang: t, escaped: n }) {
+    let s = (t || "").match(m.notSpaceStart)?.[0], r = e.replace(m.endingNewline, "") + `
+`;
+    return s ? '<pre><code class="language-' + T(s) + '">' + (n ? r : T(r, true)) + `</code></pre>
+` : "<pre><code>" + (n ? r : T(r, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: e }) {
+    return `<blockquote>
+${this.parser.parse(e)}</blockquote>
+`;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  def(e) {
+    return "";
+  }
+  heading({ tokens: e, depth: t }) {
+    return `<h${t}>${this.parser.parseInline(e)}</h${t}>
+`;
+  }
+  hr(e) {
+    return `<hr>
+`;
+  }
+  list(e) {
+    let { ordered: t, start: n } = e, s = "";
+    for (let o = 0;o < e.items.length; o++) {
+      let u = e.items[o];
+      s += this.listitem(u);
+    }
+    let r = t ? "ol" : "ul", i = t && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + r + i + `>
+` + s + "</" + r + `>
+`;
+  }
+  listitem(e) {
+    return `<li>${this.parser.parse(e.tokens)}</li>
+`;
+  }
+  checkbox({ checked: e }) {
+    return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: e }) {
+    return `<p>${this.parser.parseInline(e)}</p>
+`;
+  }
+  table(e) {
+    let t = "", n = "";
+    for (let r = 0;r < e.header.length; r++)
+      n += this.tablecell(e.header[r]);
+    t += this.tablerow({ text: n });
+    let s = "";
+    for (let r = 0;r < e.rows.length; r++) {
+      let i = e.rows[r];
+      n = "";
+      for (let o = 0;o < i.length; o++)
+        n += this.tablecell(i[o]);
+      s += this.tablerow({ text: n });
+    }
+    return s && (s = `<tbody>${s}</tbody>`), `<table>
+<thead>
+` + t + `</thead>
+` + s + `</table>
+`;
+  }
+  tablerow({ text: e }) {
+    return `<tr>
+${e}</tr>
+`;
+  }
+  tablecell(e) {
+    let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
+    return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>
+`;
+  }
+  strong({ tokens: e }) {
+    return `<strong>${this.parser.parseInline(e)}</strong>`;
+  }
+  em({ tokens: e }) {
+    return `<em>${this.parser.parseInline(e)}</em>`;
+  }
+  codespan({ text: e }) {
+    return `<code>${T(e, true)}</code>`;
+  }
+  br(e) {
+    return "<br>";
+  }
+  del({ tokens: e }) {
+    return `<del>${this.parser.parseInline(e)}</del>`;
+  }
+  link({ href: e, title: t, tokens: n }) {
+    let s = this.parser.parseInline(n), r = Y(e);
+    if (r === null)
+      return s;
+    e = r;
+    let i = '<a href="' + e + '"';
+    return t && (i += ' title="' + T(t) + '"'), i += ">" + s + "</a>", i;
+  }
+  image({ href: e, title: t, text: n, tokens: s }) {
+    s && (n = this.parser.parseInline(s, this.parser.textRenderer));
+    let r = Y(e);
+    if (r === null)
+      return T(n);
+    e = r;
+    let i = `<img src="${e}" alt="${T(n)}"`;
+    return t && (i += ` title="${T(t)}"`), i += ">", i;
+  }
+  text(e) {
+    return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : ("escaped" in e) && e.escaped ? e.text : T(e.text);
+  }
+};
+var L = class {
+  strong({ text: e }) {
+    return e;
+  }
+  em({ text: e }) {
+    return e;
+  }
+  codespan({ text: e }) {
+    return e;
+  }
+  del({ text: e }) {
+    return e;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  text({ text: e }) {
+    return e;
+  }
+  link({ text: e }) {
+    return "" + e;
+  }
+  image({ text: e }) {
+    return "" + e;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: e }) {
+    return e;
+  }
+};
+var b = class l {
+  options;
+  renderer;
+  textRenderer;
+  constructor(e) {
+    this.options = e || R, this.options.renderer = this.options.renderer || new P, this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new L;
+  }
+  static parse(e, t) {
+    return new l(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new l(t).parseInline(e);
+  }
+  parse(e) {
+    this.renderer.parser = this;
+    let t = "";
+    for (let n = 0;n < e.length; n++) {
+      let s = e[n];
+      if (this.options.extensions?.renderers?.[s.type]) {
+        let i = s, o = this.options.extensions.renderers[i.type].call({ parser: this }, i);
+        if (o !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "checkbox", "html", "def", "paragraph", "text"].includes(i.type)) {
+          t += o || "";
+          continue;
+        }
+      }
+      let r = s;
+      switch (r.type) {
+        case "space": {
+          t += this.renderer.space(r);
+          break;
+        }
+        case "hr": {
+          t += this.renderer.hr(r);
+          break;
+        }
+        case "heading": {
+          t += this.renderer.heading(r);
+          break;
+        }
+        case "code": {
+          t += this.renderer.code(r);
+          break;
+        }
+        case "table": {
+          t += this.renderer.table(r);
+          break;
+        }
+        case "blockquote": {
+          t += this.renderer.blockquote(r);
+          break;
+        }
+        case "list": {
+          t += this.renderer.list(r);
+          break;
+        }
+        case "checkbox": {
+          t += this.renderer.checkbox(r);
+          break;
+        }
+        case "html": {
+          t += this.renderer.html(r);
+          break;
+        }
+        case "def": {
+          t += this.renderer.def(r);
+          break;
+        }
+        case "paragraph": {
+          t += this.renderer.paragraph(r);
+          break;
+        }
+        case "text": {
+          t += this.renderer.text(r);
+          break;
+        }
+        default: {
+          let i = 'Token with "' + r.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(i), "";
+          throw new Error(i);
+        }
+      }
+    }
+    return t;
+  }
+  parseInline(e, t = this.renderer) {
+    this.renderer.parser = this;
+    let n = "";
+    for (let s = 0;s < e.length; s++) {
+      let r = e[s];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let o = this.options.extensions.renderers[r.type].call({ parser: this }, r);
+        if (o !== false || !["escape", "html", "link", "image", "checkbox", "strong", "em", "codespan", "br", "del", "text"].includes(r.type)) {
+          n += o || "";
+          continue;
+        }
+      }
+      let i = r;
+      switch (i.type) {
+        case "escape": {
+          n += t.text(i);
+          break;
+        }
+        case "html": {
+          n += t.html(i);
+          break;
+        }
+        case "link": {
+          n += t.link(i);
+          break;
+        }
+        case "image": {
+          n += t.image(i);
+          break;
+        }
+        case "checkbox": {
+          n += t.checkbox(i);
+          break;
+        }
+        case "strong": {
+          n += t.strong(i);
+          break;
+        }
+        case "em": {
+          n += t.em(i);
+          break;
+        }
+        case "codespan": {
+          n += t.codespan(i);
+          break;
+        }
+        case "br": {
+          n += t.br(i);
+          break;
+        }
+        case "del": {
+          n += t.del(i);
+          break;
+        }
+        case "text": {
+          n += t.text(i);
+          break;
+        }
+        default: {
+          let o = 'Token with "' + i.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(o), "";
+          throw new Error(o);
+        }
+      }
+    }
+    return n;
+  }
+};
+var S = class {
+  options;
+  block;
+  constructor(e) {
+    this.options = e || R;
+  }
+  static passThroughHooks = new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
+  static passThroughHooksRespectAsync = new Set(["preprocess", "postprocess", "processAllTokens"]);
+  preprocess(e) {
+    return e;
+  }
+  postprocess(e) {
+    return e;
+  }
+  processAllTokens(e) {
+    return e;
+  }
+  emStrongMask(e) {
+    return e;
+  }
+  provideLexer(e = this.block) {
+    return e ? x.lex : x.lexInline;
+  }
+  provideParser(e = this.block) {
+    return e ? b.parse : b.parseInline;
+  }
+};
+var Z = class {
+  defaults = A();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = b;
+  Renderer = P;
+  TextRenderer = L;
+  Lexer = x;
+  Tokenizer = y;
+  Hooks = S;
+  constructor(...e) {
+    this.use(...e);
+  }
+  walkTokens(e, t) {
+    let n = [];
+    for (let s of e)
+      switch (n = n.concat(t.call(this, s)), s.type) {
+        case "table": {
+          let r = s;
+          for (let i of r.header)
+            n = n.concat(this.walkTokens(i.tokens, t));
+          for (let i of r.rows)
+            for (let o of i)
+              n = n.concat(this.walkTokens(o.tokens, t));
+          break;
+        }
+        case "list": {
+          let r = s;
+          n = n.concat(this.walkTokens(r.items, t));
+          break;
+        }
+        default: {
+          let r = s;
+          this.defaults.extensions?.childTokens?.[r.type] ? this.defaults.extensions.childTokens[r.type].forEach((i) => {
+            let o = r[i].flat(1 / 0);
+            n = n.concat(this.walkTokens(o, t));
+          }) : r.tokens && (n = n.concat(this.walkTokens(r.tokens, t)));
+        }
+      }
+    return n;
+  }
+  use(...e) {
+    let t = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return e.forEach((n) => {
+      let s = { ...n };
+      if (s.async = this.defaults.async || s.async || false, n.extensions && (n.extensions.forEach((r) => {
+        if (!r.name)
+          throw new Error("extension name required");
+        if ("renderer" in r) {
+          let i = t.renderers[r.name];
+          i ? t.renderers[r.name] = function(...o) {
+            let u = r.renderer.apply(this, o);
+            return u === false && (u = i.apply(this, o)), u;
+          } : t.renderers[r.name] = r.renderer;
+        }
+        if ("tokenizer" in r) {
+          if (!r.level || r.level !== "block" && r.level !== "inline")
+            throw new Error("extension level must be 'block' or 'inline'");
+          let i = t[r.level];
+          i ? i.unshift(r.tokenizer) : t[r.level] = [r.tokenizer], r.start && (r.level === "block" ? t.startBlock ? t.startBlock.push(r.start) : t.startBlock = [r.start] : r.level === "inline" && (t.startInline ? t.startInline.push(r.start) : t.startInline = [r.start]));
+        }
+        "childTokens" in r && r.childTokens && (t.childTokens[r.name] = r.childTokens);
+      }), s.extensions = t), n.renderer) {
+        let r = this.defaults.renderer || new P(this.defaults);
+        for (let i in n.renderer) {
+          if (!(i in r))
+            throw new Error(`renderer '${i}' does not exist`);
+          if (["options", "parser"].includes(i))
+            continue;
+          let o = i, u = n.renderer[o], a = r[o];
+          r[o] = (...p) => {
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c || "";
+          };
+        }
+        s.renderer = r;
+      }
+      if (n.tokenizer) {
+        let r = this.defaults.tokenizer || new y(this.defaults);
+        for (let i in n.tokenizer) {
+          if (!(i in r))
+            throw new Error(`tokenizer '${i}' does not exist`);
+          if (["options", "rules", "lexer"].includes(i))
+            continue;
+          let o = i, u = n.tokenizer[o], a = r[o];
+          r[o] = (...p) => {
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.tokenizer = r;
+      }
+      if (n.hooks) {
+        let r = this.defaults.hooks || new S;
+        for (let i in n.hooks) {
+          if (!(i in r))
+            throw new Error(`hook '${i}' does not exist`);
+          if (["options", "block"].includes(i))
+            continue;
+          let o = i, u = n.hooks[o], a = r[o];
+          S.passThroughHooks.has(i) ? r[o] = (p) => {
+            if (this.defaults.async && S.passThroughHooksRespectAsync.has(i))
+              return (async () => {
+                let h = await u.call(r, p);
+                return a.call(r, h);
+              })();
+            let c = u.call(r, p);
+            return a.call(r, c);
+          } : r[o] = (...p) => {
+            if (this.defaults.async)
+              return (async () => {
+                let h = await u.apply(r, p);
+                return h === false && (h = await a.apply(r, p)), h;
+              })();
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.hooks = r;
+      }
+      if (n.walkTokens) {
+        let r = this.defaults.walkTokens, i = n.walkTokens;
+        s.walkTokens = function(o) {
+          let u = [];
+          return u.push(i.call(this, o)), r && (u = u.concat(r.call(this, o))), u;
+        };
+      }
+      this.defaults = { ...this.defaults, ...s };
+    }), this;
+  }
+  setOptions(e) {
+    return this.defaults = { ...this.defaults, ...e }, this;
+  }
+  lexer(e, t) {
+    return x.lex(e, t ?? this.defaults);
+  }
+  parser(e, t) {
+    return b.parse(e, t ?? this.defaults);
+  }
+  parseMarkdown(e) {
+    return (n, s) => {
+      let r = { ...s }, i = { ...this.defaults, ...r }, o = this.onError(!!i.silent, !!i.async);
+      if (this.defaults.async === true && r.async === false)
+        return o(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof n > "u" || n === null)
+        return o(new Error("marked(): input parameter is undefined or null"));
+      if (typeof n != "string")
+        return o(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected"));
+      if (i.hooks && (i.hooks.options = i, i.hooks.block = e), i.async)
+        return (async () => {
+          let u = i.hooks ? await i.hooks.preprocess(n) : n, p = await (i.hooks ? await i.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(u, i), c = i.hooks ? await i.hooks.processAllTokens(p) : p;
+          i.walkTokens && await Promise.all(this.walkTokens(c, i.walkTokens));
+          let d = await (i.hooks ? await i.hooks.provideParser(e) : e ? b.parse : b.parseInline)(c, i);
+          return i.hooks ? await i.hooks.postprocess(d) : d;
+        })().catch(o);
+      try {
+        i.hooks && (n = i.hooks.preprocess(n));
+        let a = (i.hooks ? i.hooks.provideLexer(e) : e ? x.lex : x.lexInline)(n, i);
+        i.hooks && (a = i.hooks.processAllTokens(a)), i.walkTokens && this.walkTokens(a, i.walkTokens);
+        let c = (i.hooks ? i.hooks.provideParser(e) : e ? b.parse : b.parseInline)(a, i);
+        return i.hooks && (c = i.hooks.postprocess(c)), c;
+      } catch (u) {
+        return o(u);
+      }
+    };
+  }
+  onError(e, t) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, e) {
+        let s = "<p>An error occurred:</p><pre>" + T(n.message + "", true) + "</pre>";
+        return t ? Promise.resolve(s) : s;
+      }
+      if (t)
+        return Promise.reject(n);
+      throw n;
+    };
+  }
+};
+var M = new Z;
+function f(l, e) {
+  return M.parse(l, e);
+}
+f.options = f.setOptions = function(l) {
+  return M.setOptions(l), f.defaults = M.defaults, j(f.defaults), f;
+};
+f.getDefaults = A;
+f.defaults = R;
+function dt(...l) {
+  return M.use(...l), f.defaults = M.defaults, j(f.defaults), f;
+}
+f.use = dt;
+f.walkTokens = function(l, e) {
+  return M.walkTokens(l, e);
+};
+f.parseInline = M.parseInline;
+f.Parser = b;
+f.parser = b.parse;
+f.Renderer = P;
+f.TextRenderer = L;
+f.Lexer = x;
+f.lexer = x.lex;
+f.Tokenizer = y;
+f.Hooks = S;
+f.parse = f;
+var nn = f.options;
+var rn = f.setOptions;
+var sn = f.walkTokens;
+var on = f.parseInline;
+var ln = b.parse;
+var un = x.lex;
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint = 161;
+var ambiguousMaximumCodePoint = 1114109;
+var ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+var fullwidthMinimalCodePoint = 12288;
+var fullwidthMaximumCodePoint = 65510;
+var fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+var wideMinimalCodePoint = 4352;
+var wideMaximumCodePoint = 262141;
+var wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js
+var isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js
+var commonCjkCodePoint = 19968;
+var [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0;index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => {
+  if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+var isFullWidth = (codePoint) => {
+  if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+var isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+
+// ../../node_modules/.bun/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/utils.js
+var graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+var wordSegmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+function getGraphemeSegmenter() {
+  return graphemeSegmenter;
+}
+function getWordSegmenter() {
+  return wordSegmenter;
+}
+function couldBeEmoji(segment) {
+  const cp = segment.codePointAt(0);
+  return cp >= 126976 && cp <= 130047 || cp >= 8960 && cp <= 9215 || cp >= 9728 && cp <= 10175 || cp >= 11088 && cp <= 11093 || segment.includes("️") || segment.length > 2;
+}
+var zeroWidthRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+var leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+var nonPrintingCharRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})$/v;
+var markCharRegex = /^\p{Mark}$/v;
+var terminalSpacingMarkRegex = /^(?:[\p{Spacing_Mark}--[\u1734\u302E\u302F]]|[\u065F\u0F7F\u102B\u102C\u1031\u1033-\u1035\u1038\u103A-\u103E])+$/v;
+var rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+var WIDTH_CACHE_SIZE = 512;
+var widthCache = new Map;
+var cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+var cjkPunctuationRegex = new RegExp(`(?:(?=\\p{Punctuation})${cjkBreakRegex.source}|[，．：；！？（）［］｛｝“”‘’…—])`, "u");
+var autocompleteSeparatorRegex = new RegExp(`(?:\\s|${cjkPunctuationRegex.source})`, "u");
+var autocompleteBoundaryRegex = new RegExp(`(?:^|${autocompleteSeparatorRegex.source})`, "u");
+function isPrintableAscii(str) {
+  for (let i = 0;i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code < 32 || code > 126) {
+      return false;
+    }
+  }
+  return true;
+}
+function truncateFragmentToWidth(text, maxWidth) {
+  if (maxWidth <= 0 || text.length === 0) {
+    return { text: "", width: 0 };
+  }
+  if (isPrintableAscii(text)) {
+    const clipped = text.slice(0, maxWidth);
+    return { text: clipped, width: clipped.length };
+  }
+  const hasAnsi = text.includes("\x1B");
+  const hasTabs = text.includes("\t");
+  if (!hasAnsi && !hasTabs) {
+    let result = "";
+    let width = 0;
+    for (const { segment } of graphemeSegmenter.segment(text)) {
+      const w = graphemeWidth(segment);
+      if (width + w > maxWidth) {
+        break;
+      }
+      result += segment;
+      width += w;
+    }
+    return { text: result, width };
+  }
+  let result = "";
+  let width = 0;
+  let i = 0;
+  let pendingAnsi = "";
+  while (i < text.length) {
+    const ansi = extractAnsiCode(text, i);
+    if (ansi) {
+      pendingAnsi += ansi.code;
+      i += ansi.length;
+      continue;
+    }
+    if (text[i] === "\t") {
+      if (width + 3 > maxWidth) {
+        break;
+      }
+      if (pendingAnsi) {
+        result += pendingAnsi;
+        pendingAnsi = "";
+      }
+      result += "\t";
+      width += 3;
+      i++;
+      continue;
+    }
+    let end = i;
+    while (end < text.length && text[end] !== "\t") {
+      const nextAnsi = extractAnsiCode(text, end);
+      if (nextAnsi) {
+        break;
+      }
+      end++;
+    }
+    for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+      const w = graphemeWidth(segment);
+      if (width + w > maxWidth) {
+        return { text: result, width };
+      }
+      if (pendingAnsi) {
+        result += pendingAnsi;
+        pendingAnsi = "";
+      }
+      result += segment;
+      width += w;
+    }
+    i = end;
+  }
+  return { text: result, width };
+}
+function finalizeTruncatedResult(prefix, prefixWidth, ellipsis, ellipsisWidth, maxWidth, pad) {
+  const reset = "\x1B[0m";
+  const hyperlinkClose = getActiveOsc8Close(prefix);
+  const visibleWidth = prefixWidth + ellipsisWidth;
+  let result;
+  if (ellipsis.length > 0) {
+    result = `${prefix}${hyperlinkClose}${reset}${ellipsis}${reset}`;
+  } else {
+    result = `${prefix}${hyperlinkClose}${reset}`;
+  }
+  return pad ? result + " ".repeat(Math.max(0, maxWidth - visibleWidth)) : result;
+}
+function graphemeWidth(segment) {
+  if (segment.length === 1) {
+    const code = segment.charCodeAt(0);
+    if (code >= 32 && code <= 126)
+      return 1;
+    if (code === 9)
+      return 3;
+  }
+  if (terminalSpacingMarkRegex.test(segment)) {
+    return [...segment].length;
+  }
+  if (zeroWidthRegex.test(segment)) {
+    return 0;
+  }
+  if (couldBeEmoji(segment) && rgiEmojiRegex.test(segment)) {
+    return 2;
+  }
+  const base = segment.replace(leadingNonPrintingRegex, "");
+  const cp = base.codePointAt(0);
+  if (cp === undefined) {
+    return 0;
+  }
+  if (cp >= 127462 && cp <= 127487) {
+    return 2;
+  }
+  let width = eastAsianWidth(cp);
+  let followsMark = false;
+  const chars = [...base];
+  for (const char of chars.slice(1)) {
+    if (terminalSpacingMarkRegex.test(char)) {
+      width += 1;
+      followsMark = false;
+    } else if (markCharRegex.test(char)) {
+      followsMark = true;
+    } else if (!nonPrintingCharRegex.test(char)) {
+      const c = char.codePointAt(0);
+      if (followsMark || c >= 65280 && c <= 65519) {
+        width += eastAsianWidth(c);
+      } else if (c === 3635 || c === 3763) {
+        width += 1;
+      }
+      followsMark = false;
+    }
+  }
+  return width;
+}
+function visibleWidth(str) {
+  if (str.length === 0) {
+    return 0;
+  }
+  const asciiWidth = asciiVisibleWidth(str);
+  if (asciiWidth !== -1) {
+    return asciiWidth;
+  }
+  const cached = widthCache.get(str);
+  if (cached !== undefined) {
+    return cached;
+  }
+  let clean = str;
+  if (str.includes("\t")) {
+    clean = clean.replace(/\t/g, "   ");
+  }
+  let escapeIndex = clean.indexOf("\x1B");
+  if (escapeIndex !== -1) {
+    let stripped = "";
+    let copyFrom = 0;
+    while (escapeIndex !== -1) {
+      const length = ansiCodeLength(clean, escapeIndex);
+      if (length > 0) {
+        stripped += clean.slice(copyFrom, escapeIndex);
+        escapeIndex += length;
+        copyFrom = escapeIndex;
+      } else {
+        escapeIndex++;
+      }
+      escapeIndex = clean.indexOf("\x1B", escapeIndex);
+    }
+    clean = stripped + clean.slice(copyFrom);
+  }
+  let width = 0;
+  for (const { segment } of graphemeSegmenter.segment(clean)) {
+    width += graphemeWidth(segment);
+  }
+  if (widthCache.size >= WIDTH_CACHE_SIZE) {
+    const firstKey = widthCache.keys().next().value;
+    if (firstKey !== undefined) {
+      widthCache.delete(firstKey);
+    }
+  }
+  widthCache.set(str, width);
+  return width;
+}
+function extractAnsiCode(str, pos) {
+  const length = ansiCodeLength(str, pos);
+  return length > 0 ? { code: str.substring(pos, pos + length), length } : null;
+}
+function asciiVisibleWidth(str) {
+  let width = 0;
+  let i = 0;
+  while (i < str.length) {
+    const code = str.charCodeAt(i);
+    if (code >= 32 && code <= 126) {
+      width++;
+      i++;
+    } else if (code === 9) {
+      width += 3;
+      i++;
+    } else if (code === 27) {
+      const length = ansiCodeLength(str, i);
+      if (length === 0)
+        return -1;
+      i += length;
+    } else {
+      return -1;
+    }
+  }
+  return width;
+}
+function ansiCodeLength(str, pos) {
+  if (pos >= str.length || str.charCodeAt(pos) !== 27)
+    return 0;
+  const next = str[pos + 1];
+  if (next === "[") {
+    for (let j = pos + 2;j < str.length; j++) {
+      const c = str.charCodeAt(j);
+      if (c === 109 || c === 71 || c === 75 || c === 72 || c === 74)
+        return j + 1 - pos;
+    }
+    return 0;
+  }
+  if (next === "]" || next === "_") {
+    for (let j = pos + 2;j < str.length; j++) {
+      const c = str.charCodeAt(j);
+      if (c === 7)
+        return j + 1 - pos;
+      if (c === 27 && str[j + 1] === "\\")
+        return j + 2 - pos;
+    }
+    return 0;
+  }
+  return 0;
+}
+function parseOsc8Hyperlink(ansiCode) {
+  if (!ansiCode.startsWith("\x1B]8;")) {
+    return;
+  }
+  const terminator = ansiCode.endsWith("\x07") ? "\x07" : "\x1B\\";
+  const body = ansiCode.slice(4, terminator === "\x07" ? -1 : -2);
+  const separatorIndex = body.indexOf(";");
+  if (separatorIndex === -1) {
+    return;
+  }
+  const params = body.slice(0, separatorIndex);
+  const url = body.slice(separatorIndex + 1);
+  if (!url) {
+    return null;
+  }
+  return { params, url, terminator };
+}
+function formatOsc8Hyperlink(hyperlink) {
+  return `\x1B]8;${hyperlink.params};${hyperlink.url}${hyperlink.terminator}`;
+}
+function formatOsc8Close(terminator) {
+  return `\x1B]8;;${terminator}`;
+}
+function getActiveOsc8Close(prefix) {
+  if (!prefix.includes("\x1B]8;")) {
+    return "";
+  }
+  let activeHyperlink = null;
+  let i = 0;
+  while (i < prefix.length) {
+    const ansi = extractAnsiCode(prefix, i);
+    if (ansi) {
+      const hyperlink = parseOsc8Hyperlink(ansi.code);
+      if (hyperlink !== undefined) {
+        activeHyperlink = hyperlink;
+      }
+      i += ansi.length;
+    } else {
+      i++;
+    }
+  }
+  return activeHyperlink ? formatOsc8Close(activeHyperlink.terminator) : "";
+}
+
+class AnsiCodeTracker {
+  bold = false;
+  dim = false;
+  italic = false;
+  underline = false;
+  blink = false;
+  inverse = false;
+  hidden = false;
+  strikethrough = false;
+  fgColor = null;
+  bgColor = null;
+  activeHyperlink = null;
+  process(ansiCode) {
+    const hyperlink = parseOsc8Hyperlink(ansiCode);
+    if (hyperlink !== undefined) {
+      this.activeHyperlink = hyperlink;
+      return;
+    }
+    if (!ansiCode.endsWith("m")) {
+      return;
+    }
+    const match = ansiCode.match(/\x1b\[([\d;]*)m/);
+    if (!match)
+      return;
+    const params = match[1];
+    if (params === "" || params === "0") {
+      this.reset();
+      return;
+    }
+    const parts = params.split(";");
+    let i = 0;
+    while (i < parts.length) {
+      const code = Number.parseInt(parts[i], 10);
+      if (code === 38 || code === 48) {
+        if (parts[i + 1] === "5" && parts[i + 2] !== undefined) {
+          const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]}`;
+          if (code === 38) {
+            this.fgColor = colorCode;
+          } else {
+            this.bgColor = colorCode;
+          }
+          i += 3;
+          continue;
+        } else if (parts[i + 1] === "2" && parts[i + 4] !== undefined) {
+          const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]};${parts[i + 3]};${parts[i + 4]}`;
+          if (code === 38) {
+            this.fgColor = colorCode;
+          } else {
+            this.bgColor = colorCode;
+          }
+          i += 5;
+          continue;
+        }
+      }
+      switch (code) {
+        case 0:
+          this.reset();
+          break;
+        case 1:
+          this.bold = true;
+          break;
+        case 2:
+          this.dim = true;
+          break;
+        case 3:
+          this.italic = true;
+          break;
+        case 4:
+          this.underline = true;
+          break;
+        case 5:
+          this.blink = true;
+          break;
+        case 7:
+          this.inverse = true;
+          break;
+        case 8:
+          this.hidden = true;
+          break;
+        case 9:
+          this.strikethrough = true;
+          break;
+        case 21:
+          this.bold = false;
+          break;
+        case 22:
+          this.bold = false;
+          this.dim = false;
+          break;
+        case 23:
+          this.italic = false;
+          break;
+        case 24:
+          this.underline = false;
+          break;
+        case 25:
+          this.blink = false;
+          break;
+        case 27:
+          this.inverse = false;
+          break;
+        case 28:
+          this.hidden = false;
+          break;
+        case 29:
+          this.strikethrough = false;
+          break;
+        case 39:
+          this.fgColor = null;
+          break;
+        case 49:
+          this.bgColor = null;
+          break;
+        default:
+          if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+            this.fgColor = String(code);
+          } else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+            this.bgColor = String(code);
+          }
+          break;
+      }
+      i++;
+    }
+  }
+  reset() {
+    this.bold = false;
+    this.dim = false;
+    this.italic = false;
+    this.underline = false;
+    this.blink = false;
+    this.inverse = false;
+    this.hidden = false;
+    this.strikethrough = false;
+    this.fgColor = null;
+    this.bgColor = null;
+  }
+  clear() {
+    this.reset();
+    this.activeHyperlink = null;
+  }
+  getActiveCodes() {
+    const codes = [];
+    if (this.bold)
+      codes.push("1");
+    if (this.dim)
+      codes.push("2");
+    if (this.italic)
+      codes.push("3");
+    if (this.underline)
+      codes.push("4");
+    if (this.blink)
+      codes.push("5");
+    if (this.inverse)
+      codes.push("7");
+    if (this.hidden)
+      codes.push("8");
+    if (this.strikethrough)
+      codes.push("9");
+    if (this.fgColor)
+      codes.push(this.fgColor);
+    if (this.bgColor)
+      codes.push(this.bgColor);
+    let result = codes.length > 0 ? `\x1B[${codes.join(";")}m` : "";
+    if (this.activeHyperlink) {
+      result += formatOsc8Hyperlink(this.activeHyperlink);
+    }
+    return result;
+  }
+  getActiveBackgroundCode() {
+    return this.bgColor ? `\x1B[${this.bgColor}m` : "";
+  }
+  hasActiveCodes() {
+    return this.bold || this.dim || this.italic || this.underline || this.blink || this.inverse || this.hidden || this.strikethrough || this.fgColor !== null || this.bgColor !== null || this.activeHyperlink !== null;
+  }
+  getLineEndReset() {
+    let result = "";
+    if (this.underline) {
+      result += "\x1B[24m";
+    }
+    if (this.activeHyperlink) {
+      result += formatOsc8Close(this.activeHyperlink.terminator);
+    }
+    return result;
+  }
+}
+function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
+  if (maxWidth <= 0) {
+    return "";
+  }
+  if (text.length === 0) {
+    return pad ? " ".repeat(maxWidth) : "";
+  }
+  const ellipsisWidth = visibleWidth(ellipsis);
+  if (ellipsisWidth >= maxWidth) {
+    const textWidth = visibleWidth(text);
+    if (textWidth <= maxWidth) {
+      return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+    }
+    const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+    if (clippedEllipsis.width === 0) {
+      return pad ? " ".repeat(maxWidth) : "";
+    }
+    return finalizeTruncatedResult("", 0, clippedEllipsis.text, clippedEllipsis.width, maxWidth, pad);
+  }
+  if (isPrintableAscii(text)) {
+    if (text.length <= maxWidth) {
+      return pad ? text + " ".repeat(maxWidth - text.length) : text;
+    }
+    const targetWidth = maxWidth - ellipsisWidth;
+    return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+  }
+  const targetWidth = maxWidth - ellipsisWidth;
+  let result = "";
+  let pendingAnsi = "";
+  let visibleSoFar = 0;
+  let keptWidth = 0;
+  let keepContiguousPrefix = true;
+  let overflowed = false;
+  let exhaustedInput = false;
+  const hasAnsi = text.includes("\x1B");
+  const hasTabs = text.includes("\t");
+  if (!hasAnsi && !hasTabs) {
+    for (const { segment } of graphemeSegmenter.segment(text)) {
+      const width = graphemeWidth(segment);
+      if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+        result += segment;
+        keptWidth += width;
+      } else {
+        keepContiguousPrefix = false;
+      }
+      visibleSoFar += width;
+      if (visibleSoFar > maxWidth) {
+        overflowed = true;
+        break;
+      }
+    }
+    exhaustedInput = !overflowed;
+  } else {
+    let i = 0;
+    while (i < text.length) {
+      const ansi = extractAnsiCode(text, i);
+      if (ansi) {
+        pendingAnsi += ansi.code;
+        i += ansi.length;
+        continue;
+      }
+      if (text[i] === "\t") {
+        if (keepContiguousPrefix && keptWidth + 3 <= targetWidth) {
+          if (pendingAnsi) {
+            result += pendingAnsi;
+            pendingAnsi = "";
+          }
+          result += "\t";
+          keptWidth += 3;
+        } else {
+          keepContiguousPrefix = false;
+          pendingAnsi = "";
+        }
+        visibleSoFar += 3;
+        if (visibleSoFar > maxWidth) {
+          overflowed = true;
+          break;
+        }
+        i++;
+        continue;
+      }
+      let end = i;
+      while (end < text.length && text[end] !== "\t") {
+        const nextAnsi = extractAnsiCode(text, end);
+        if (nextAnsi) {
+          break;
+        }
+        end++;
+      }
+      for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+        const width = graphemeWidth(segment);
+        if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+          if (pendingAnsi) {
+            result += pendingAnsi;
+            pendingAnsi = "";
+          }
+          result += segment;
+          keptWidth += width;
+        } else {
+          keepContiguousPrefix = false;
+          pendingAnsi = "";
+        }
+        visibleSoFar += width;
+        if (visibleSoFar > maxWidth) {
+          overflowed = true;
+          break;
+        }
+      }
+      if (overflowed) {
+        break;
+      }
+      i = end;
+    }
+    exhaustedInput = i >= text.length;
+  }
+  if (!overflowed && exhaustedInput) {
+    return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleSoFar)) : text;
+  }
+  return finalizeTruncatedResult(result, keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+var pooledStyleTracker = new AnsiCodeTracker;
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/autocomplete.js
+var PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
+var tokenStartRegex = new RegExp(`${autocompleteBoundaryRegex.source}$`, "u");
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/oklab.js
+var K1 = 0.206;
+var K2 = 0.03;
+var K3 = (1 + K1) / (1 + K2);
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/colors.js
+var NUMBER_PATTERN = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?`;
+var OKLCH_PATTERN = new RegExp(`^oklch\\(\\s*(${NUMBER_PATTERN})(%)?\\s+(${NUMBER_PATTERN})\\s+(${NUMBER_PATTERN})(?:deg)?\\s*\\)$`, "i");
+var OKHSL_PATTERN = new RegExp(`^okhsl\\(\\s*(${NUMBER_PATTERN})(?:deg)?\\s+(${NUMBER_PATTERN})(%)?\\s+(${NUMBER_PATTERN})(%)?\\s*\\)$`, "i");
+var GRAY_VALUES = Array.from({ length: 24 }, (_, index) => 8 + index * 10);
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/keys.js
+var SYMBOL_KEYS = new Set([
+  "`",
+  "-",
+  "=",
+  "[",
+  "]",
+  "\\",
+  ";",
+  "'",
+  ",",
+  ".",
+  "/",
+  "!",
+  "@",
+  "#",
+  "$",
+  "%",
+  "^",
+  "&",
+  "*",
+  "(",
+  ")",
+  "_",
+  "+",
+  "|",
+  "~",
+  "{",
+  "}",
+  ":",
+  "<",
+  ">",
+  "?"
+]);
+var SHIFTED_SYMBOL_KEYS = new Set("~!@#$%^&*()_+|{}:<>?");
+var MODIFIERS = {
+  shift: 1,
+  alt: 2,
+  ctrl: 4,
+  super: 8
+};
+var LOCK_MASK = 64 + 128;
+var ARROW_CODEPOINTS = {
+  up: -1,
+  down: -2,
+  right: -3,
+  left: -4
+};
+var FUNCTIONAL_CODEPOINTS = {
+  delete: -10,
+  insert: -11,
+  pageUp: -12,
+  pageDown: -13,
+  home: -14,
+  end: -15
+};
+var KITTY_FUNCTIONAL_KEY_EQUIVALENTS = new Map([
+  [57399, 48],
+  [57400, 49],
+  [57401, 50],
+  [57402, 51],
+  [57403, 52],
+  [57404, 53],
+  [57405, 54],
+  [57406, 55],
+  [57407, 56],
+  [57408, 57],
+  [57409, 46],
+  [57410, 47],
+  [57411, 42],
+  [57412, 45],
+  [57413, 43],
+  [57415, 61],
+  [57416, 44],
+  [57417, ARROW_CODEPOINTS.left],
+  [57418, ARROW_CODEPOINTS.right],
+  [57419, ARROW_CODEPOINTS.up],
+  [57420, ARROW_CODEPOINTS.down],
+  [57421, FUNCTIONAL_CODEPOINTS.pageUp],
+  [57422, FUNCTIONAL_CODEPOINTS.pageDown],
+  [57423, FUNCTIONAL_CODEPOINTS.home],
+  [57424, FUNCTIONAL_CODEPOINTS.end],
+  [57425, FUNCTIONAL_CODEPOINTS.insert],
+  [57426, FUNCTIONAL_CODEPOINTS.delete]
+]);
+var KITTY_PRINTABLE_ALLOWED_MODIFIERS = MODIFIERS.shift | LOCK_MASK;
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/terminal-image.js
+var kittyImageMetadata = new Map;
+var KITTY_PLACEMENT_CONTROL_KEYS = new Set([
+  "i",
+  "p",
+  "x",
+  "y",
+  "w",
+  "h",
+  "X",
+  "Y",
+  "c",
+  "r",
+  "C",
+  "U",
+  "z",
+  "P",
+  "Q",
+  "H",
+  "V"
+]);
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/tui.js
+var TERMINAL_PALETTE_SIZE = 16;
+var TERMINAL_COLOR_REPLY_COUNT = 2 + TERMINAL_PALETTE_SIZE;
+var TERMINAL_COLOR_QUERY = `\x1B]10;?\x07\x1B]11;?\x07${Array.from({ length: TERMINAL_PALETTE_SIZE }, (_, index) => `\x1B]4;${index};?\x07`).join("")}\x1B[c`;
+var VIEWPORT_TUI = Symbol.for("@earendil-works/pi-tui/viewport");
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/word-navigation.js
+var wordSegmenter2 = getWordSegmenter();
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/components/editor.js
+var graphemeSegmenter2 = getGraphemeSegmenter();
+var wordSegmenter3 = getWordSegmenter();
+var unquotedAutocompleteSuffixRegex = new RegExp(`(?:(?!${autocompleteSeparatorRegex.source}).)*`, "u");
+var autocompleteTokenStartSource = `${autocompleteBoundaryRegex.source}[([{<\`]*`;
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/layout-node.js
+var LAYOUT_NODE = Symbol.for("@earendil-works/pi-tui/layout-node");
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/components/image.js
+var pngCache = new Map;
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/components/input.js
+var segmenter = getGraphemeSegmenter();
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/latex.js
+var NAMED_OPERATORS = new Set([
+  "arccos",
+  "arcsin",
+  "arctan",
+  "arg",
+  "cos",
+  "cosh",
+  "cot",
+  "coth",
+  "csc",
+  "deg",
+  "det",
+  "dim",
+  "exp",
+  "gcd",
+  "hom",
+  "inf",
+  "ker",
+  "lg",
+  "lim",
+  "liminf",
+  "limsup",
+  "ln",
+  "log",
+  "max",
+  "min",
+  "Pr",
+  "sec",
+  "sin",
+  "sinh",
+  "sup",
+  "tan",
+  "tanh"
+]);
+var LIMIT_OPERATORS = new Set([
+  "argmax",
+  "argmin",
+  "inf",
+  "injlim",
+  "lim",
+  "liminf",
+  "limsup",
+  "max",
+  "min",
+  "projlim",
+  "sup"
+]);
+var DISPLAY_LIMIT_SYMBOLS = new Set([
+  "bigcap",
+  "bigcup",
+  "bigodot",
+  "bigoplus",
+  "bigotimes",
+  "bigsqcup",
+  "biguplus",
+  "bigvee",
+  "bigwedge",
+  "coprod",
+  "int",
+  "iint",
+  "iiint",
+  "oint",
+  "prod",
+  "sum"
+]);
+var RELATION_COMMANDS = new Set([
+  "Leftarrow",
+  "Leftrightarrow",
+  "Longleftarrow",
+  "Longleftrightarrow",
+  "Longrightarrow",
+  "Rightarrow",
+  "Join",
+  "Vdash",
+  "Vvdash",
+  "approx",
+  "asymp",
+  "bowtie",
+  "cong",
+  "dashv",
+  "fullouterjoin",
+  "doteq",
+  "downarrow",
+  "equiv",
+  "ge",
+  "geq",
+  "geqslant",
+  "gets",
+  "gg",
+  "hookleftarrow",
+  "hookrightarrow",
+  "iff",
+  "implies",
+  "in",
+  "leadsto",
+  "le",
+  "leftarrow",
+  "leftharpoondown",
+  "leftharpoonup",
+  "leftrightarrow",
+  "leftrightharpoons",
+  "leftouterjoin",
+  "leq",
+  "leqslant",
+  "ll",
+  "longleftarrow",
+  "longleftrightarrow",
+  "longmapsto",
+  "longrightarrow",
+  "ltimes",
+  "mapsto",
+  "mid",
+  "models",
+  "ne",
+  "nearrow",
+  "neq",
+  "ni",
+  "notin",
+  "nvdash",
+  "nvDash",
+  "nwarrow",
+  "parallel",
+  "perp",
+  "prec",
+  "preceq",
+  "propto",
+  "rightharpoondown",
+  "rightharpoonup",
+  "rightleftharpoons",
+  "rightouterjoin",
+  "rightarrow",
+  "rightsquigarrow",
+  "rtimes",
+  "searrow",
+  "sim",
+  "simeq",
+  "sqsubset",
+  "sqsubseteq",
+  "sqsupset",
+  "sqsupseteq",
+  "subset",
+  "subseteq",
+  "succ",
+  "succeq",
+  "supset",
+  "supseteq",
+  "swarrow",
+  "to",
+  "triangleleft",
+  "triangleright",
+  "twoheadleftarrow",
+  "twoheadrightarrow",
+  "uparrow",
+  "vdash"
+]);
+var SPACING_COMMANDS = new Set([
+  ",",
+  ":",
+  ";",
+  " ",
+  ">",
+  "enspace",
+  "enskip",
+  "medspace",
+  "quad",
+  "qquad",
+  "thickspace",
+  "thinspace"
+]);
+var NEGATIVE_SPACING_COMMANDS = new Set(["!", "negmedspace", "negthickspace", "negthinspace"]);
+var FONT_SWITCH_COMMANDS = new Set(["bf", "cal", "it", "rm", "sf", "sl", "tt"]);
+var IGNORED_COMMANDS = new Set([
+  "displaystyle",
+  "limits",
+  "nolimits",
+  "scriptstyle",
+  "scriptscriptstyle",
+  "textstyle"
+]);
+var SIZE_COMMANDS = new Set([
+  "big",
+  "Big",
+  "bigg",
+  "Bigg",
+  "bigl",
+  "Bigl",
+  "biggl",
+  "Biggl",
+  "bigr",
+  "Bigr",
+  "biggr",
+  "Biggr"
+]);
+var PLAIN_WRAPPERS = new Set([
+  "emph",
+  "mathcal",
+  "mathbf",
+  "mathfrak",
+  "mathit",
+  "mathrm",
+  "mathnormal",
+  "mathscr",
+  "mathsf",
+  "mathtt",
+  "mathup",
+  "mbox",
+  "overbrace",
+  "pmb",
+  "smash",
+  "substack",
+  "text",
+  "textbf",
+  "textit",
+  "textmd",
+  "textnormal",
+  "textrm",
+  "textsc",
+  "textsf",
+  "textsl",
+  "texttt",
+  "textup",
+  "underbrace",
+  "bm",
+  "boldsymbol"
+]);
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/components/markdown.js
+var STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
+
+class StrictStrikethroughTokenizer extends y {
+  del(src) {
+    const match = STRICT_STRIKETHROUGH_REGEX.exec(src);
+    if (!match) {
+      return;
+    }
+    const text = match[2];
+    return {
+      type: "del",
+      raw: match[0],
+      text,
+      tokens: this.lexer.inlineTokens(text)
+    };
+  }
+}
+function isEscaped(source, index) {
+  let backslashes = 0;
+  for (let position = index - 1;position >= 0 && source[position] === "\\"; position--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 1;
+}
+function findClosingDelimiter(source, closing, start) {
+  let index = source.indexOf(closing, start);
+  while (index >= 0 && isEscaped(source, index)) {
+    index = source.indexOf(closing, index + closing.length);
+  }
+  return index;
+}
+function looksLikePendingDollarMath(source) {
+  return /\\[A-Za-z]+|[_^=+*/<>()[\]|±≤≥≠≈∈→⇒∞∫∑√-]/.test(source);
+}
+function tokenizeInlineLatex(source) {
+  let opening = "";
+  let closing = "";
+  if (source.startsWith("$$")) {
+    opening = "$$";
+    closing = "$$";
+  } else if (source.startsWith("\\(")) {
+    opening = "\\(";
+    closing = "\\)";
+  } else if (source.startsWith("\\[")) {
+    opening = "\\[";
+    closing = "\\]";
+  } else if (source.startsWith("$") && !/^\$\s/.test(source)) {
+    opening = "$";
+    closing = "$";
+  } else {
+    return;
+  }
+  const closingIndex = findClosingDelimiter(source, closing, opening.length);
+  if (closingIndex >= 0 && opening === "$" && (/\s$/.test(source.slice(opening.length, closingIndex)) || /^\d/.test(source.slice(closingIndex + 1)) || /^[A-Z_][A-Z0-9_]*(?:[^A-Za-z0-9_\s])?$/.test(source.slice(opening.length, closingIndex)) && /^[A-Za-z_][A-Za-z0-9_]*/.test(source.slice(closingIndex + 1)) || source.slice(opening.length, closingIndex).includes("`"))) {
+    return;
+  }
+  if (closingIndex < 0) {
+    const pendingSource = source.slice(opening.length);
+    if (opening.startsWith("\\") || looksLikePendingDollarMath(pendingSource)) {
+      return { type: "latex", raw: source, text: pendingSource, pending: true };
+    }
+    return;
+  }
+  const text = source.slice(opening.length, closingIndex);
+  if (!text || text.includes(`
+`)) {
+    return;
+  }
+  const raw = source.slice(0, closingIndex + closing.length);
+  return { type: "latex", raw, text };
+}
+function tokenizeBlockLatex(source) {
+  const dollarMatch = /^ {0,3}\$\$[ \t]*(?:\n)?([\s\S]*?)\$\$[ \t]*(?:\n|$)/.exec(source);
+  if (dollarMatch?.[1]) {
+    return { type: "latexBlock", raw: dollarMatch[0], text: dollarMatch[1].trim() };
+  }
+  const bracketMatch = /^ {0,3}\\\[[ \t]*(?:\n)?([\s\S]*?)\\\][ \t]*(?:\n|$)/.exec(source);
+  if (bracketMatch?.[1]) {
+    return { type: "latexBlock", raw: bracketMatch[0], text: bracketMatch[1].trim() };
+  }
+  const pendingBracket = /^ {0,3}\\\[[ \t]*(?:\n)?([\s\S]*)$/.exec(source);
+  if (pendingBracket) {
+    return { type: "latexBlock", raw: pendingBracket[0], text: pendingBracket[1], pending: true };
+  }
+  const pendingDollar = /^ {0,3}\$\$[ \t]*(?:\n)?([\s\S]*)$/.exec(source);
+  if (pendingDollar?.[1] && looksLikePendingDollarMath(pendingDollar[1])) {
+    return { type: "latexBlock", raw: pendingDollar[0], text: pendingDollar[1], pending: true };
+  }
+  return;
+}
+var LATEX_MARKDOWN_EXTENSIONS = [
+  {
+    name: "latexBlock",
+    level: "block",
+    start(source) {
+      const match = /(?:^|\n) {0,3}(?:\$\$|\\\[)/.exec(source);
+      return match ? match.index + (match[0].startsWith(`
+`) ? 1 : 0) : undefined;
+    },
+    tokenizer: tokenizeBlockLatex
+  },
+  {
+    name: "latex",
+    level: "inline",
+    start(source) {
+      const indices = [source.indexOf("$"), source.indexOf("\\("), source.indexOf("\\[")].filter((index) => index >= 0);
+      return indices.length > 0 ? Math.min(...indices) : undefined;
+    },
+    tokenizer: tokenizeInlineLatex
+  }
+];
+var markdownParser = new Z;
+markdownParser.setOptions({
+  tokenizer: new StrictStrikethroughTokenizer
+});
+markdownParser.use({ extensions: [...LATEX_MARKDOWN_EXTENSIONS] });
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/native-platform.js
+import { createRequire as createRequire2 } from "node:module";
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/native-module-path.js
+import { createRequire } from "node:module";
+var moduleRequire = createRequire(import.meta.url);
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/native-platform.js
+var cjsRequire = createRequire2(import.meta.url);
+var helpers = new Map;
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/terminal.js
+var DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS = 7;
+var KITTY_KEYBOARD_PROTOCOL_QUERY = `\x1B[>${DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS}u\x1B[?u`;
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/alt-screen-search.js
+var segmenter2 = getGraphemeSegmenter();
+
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/tui-alt-screen.js
+var MAX_CACHED_OFFSCREEN_KITTY_TRANSMISSION_BYTES = 32 * 1024 * 1024;
+var MAX_CACHED_OFFSCREEN_KITTY_DECODED_BYTES = 64 * 1024 * 1024;
+var TERMINAL_WORD_SELECTION_JOINERS = new Set(["/", "-"]);
+var wordSegmenter4 = getWordSegmenter();
+// ../../node_modules/.bun/@earendil-works+pi-tui@1.2.0/node_modules/@earendil-works/pi-tui/dist/tui-main-screen.js
+var MAX_RENDER_WRITE_CHARS = 1024 * 1024;
+// ../pi-ads/src/style.ts
 var OSC_RE = /\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
 var CSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
 var C1_RE = /[\x80-\x9f]/g;
@@ -5245,17 +7825,8 @@ var C0_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
 function sanitizeText(input) {
   return input.replace(OSC_RE, "").replace(CSI_RE, "").replace(/\x1b/g, "").replace(C1_RE, "").replace(/[\t\r\n]+/g, " ").replace(C0_RE, "").trim();
 }
-function truncate(text, maxWidth) {
-  if (maxWidth <= 0)
-    return "";
-  if (text.length <= maxWidth)
-    return text;
-  if (maxWidth <= 1)
-    return text.slice(0, maxWidth);
-  return `${text.slice(0, maxWidth - 1)}…`;
-}
-function pad(text, width) {
-  return text.length >= width ? text.slice(0, width) : text + " ".repeat(width - text.length);
+function fit(text, width) {
+  return truncateToWidth(text, Math.max(0, width), "…", true);
 }
 function osc8(text, url, id) {
   const params = id ? `id=${id}` : "";
@@ -5272,7 +7843,7 @@ function renderAdCard(creative, clickUrl, theme, columns) {
   const bottom = `└${"─".repeat(innerWidth + 2)}┘`;
   const linkId = createHash2("sha256").update(url).digest("hex").slice(0, 12);
   const row = (text, opts) => {
-    const plain = pad(truncate(text, innerWidth), innerWidth);
+    const plain = fit(text, innerWidth);
     let styled = theme.fg("accent", plain);
     if (opts?.bold)
       styled = theme.bold(styled);
@@ -5290,9 +7861,16 @@ function renderPlainAdLine(creative, clickUrl, theme, columns) {
   const headline = sanitizeText(creative.headline);
   const cta = sanitizeText(creative.cta);
   const url = sanitizeText(clickUrl);
-  const plain = truncate(`AD ▚ ${headline} — ${cta}`, Math.max(10, columns - 2));
+  const plain = truncateToWidth(`AD ▚ ${headline} — ${cta}`, Math.max(0, columns - 2), "…");
   return theme.fg("dim", osc8(plain, url));
 }
+var CARD_MIN_COLUMNS = 25;
+function adWidget(creative, clickUrl, adMinColumns) {
+  return (_tui, theme) => ({
+    render: (width) => width < 1 ? [] : (width >= Math.max(adMinColumns, CARD_MIN_COLUMNS) ? renderAdCard(creative, clickUrl, theme, width) : [renderPlainAdLine(creative, clickUrl, theme, width)]).map((line) => ` ${line}`),
+    invalidate() {}
+  });
+}
 function renderErrorLine(message, theme) {
   return theme.fg("error", message);
 }
@@ -5306,7 +7884,7 @@ function createBannerRenderer(opts = {}) {
   let lastPostedToken;
   const screen = opts.screen ?? {};
   return {
-    async render(deps, ctx, config, columnsOverride) {
+    async render(deps, ctx, config) {
       const ad = await fetchAdNext(deps, "banner");
       if (opts.isActive && !opts.isActive())
         return;
@@ -5331,10 +7909,7 @@ function createBannerRenderer(opts = {}) {
         ctx.ui.setWidget(BANNER_WIDGET_ID, undefined);
         opts.onBannerAd?.(undefined);
       };
-      const theme = ctx.ui.theme;
-      const columns = columnsOverride ?? process.stdout.columns ?? 80;
-      const lines = columns >= config.adMinColumns ? renderAdCard(ad.creative, ad.click_url, theme, columns) : [renderPlainAdLine(ad.creative, ad.click_url, theme, columns)];
-      ctx.ui.setWidget(BANNER_WIDGET_ID, lines);
+      ctx.ui.setWidget(BANNER_WIDGET_ID, adWidget(ad.creative, ad.click_url, config.adMinColumns));
       opts.onBannerAd?.(ad.click_url);
       if (lastPostedToken !== ad.click_token) {
         lastPostedToken = ad.click_token;
@@ -5358,7 +7933,7 @@ function createInlineRenderer(screen = {}) {
     screen.inline = undefined;
   };
   return {
-    async onTurnEnd(deps, ctx, config, columnsOverride) {
+    async onTurnEnd(deps, ctx, config) {
       turnCount += 1;
       clearInline(ctx);
       if (turnCount % config.adInlineTurnFrequency !== 0)
@@ -5373,10 +7948,7 @@ function createInlineRenderer(screen = {}) {
         return;
       if (isGravity && screen.banner)
         screen.clearBanner?.();
-      const theme = ctx.ui.theme;
-      const columns = columnsOverride ?? process.stdout.columns ?? 80;
-      const lines = columns >= config.adMinColumns ? renderAdCard(ad.creative, ad.click_url, theme, columns) : [renderPlainAdLine(ad.creative, ad.click_url, theme, columns)];
-      ctx.ui.setWidget(INLINE_WIDGET_ID, lines, { placement: "belowEditor" });
+      ctx.ui.setWidget(INLINE_WIDGET_ID, adWidget(ad.creative, ad.click_url, config.adMinColumns), { placement: "belowEditor" });
       inlineVisible = true;
       screen.inline = isGravity ? "gravity" : "own";
       screen.clearInline = () => clearInline(ctx);
@@ -5840,6 +8412,9 @@ var F64Out = new Uint8Array(F64.buffer);
 var encoder = new TextEncoder;
 // ../../node_modules/.bun/typebox@1.3.27/node_modules/typebox/build/type/types/integer.mjs
 var IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+function Integer(options) {
+  return Create({ "~kind": "Integer" }, { type: "integer" }, options);
+}
 // ../../node_modules/.bun/typebox@1.3.27/node_modules/typebox/build/type/types/literal.mjs
 class InvalidLiteralValue extends Error {
   constructor(value) {
@@ -5970,6 +8545,106 @@ function createUsageToolExtension(opts) {
   };
 }
 
+// src/web-tools.ts
+var WEB_SEARCH_TOOL_NAME = "web_search";
+var DOCS_LOOKUP_TOOL_NAME = "docs_lookup";
+var COST_GUIDELINE = "Each web_search or docs_lookup call costs part of the user's daily allowance; one or two well-aimed calls usually suffice.";
+var DOCS_LOOKUP_GUIDELINES = [
+  "Use docs_lookup before writing or fixing code against a third-party library, framework, SDK or API whose exact signature or config you are not sure of, and whenever an import, method or option you used turns out not to exist.",
+  'Pass the package name as `library` (e.g. "next.js", "prisma", "@tanstack/react-query") and one specific question as `query` (e.g. "configure middleware matcher for API routes"), not a bare topic. Reuse the returned `library_id` for follow-up lookups on the same library.',
+  COST_GUIDELINE
+];
+var WEB_SEARCH_GUIDELINES = [
+  "Use web_search for things that change or are newer than your knowledge: release notes, current versions, exact error messages you cannot explain from the code, service status, and pages the user links or mentions. Prefer docs_lookup for library API docs, and read/grep for anything in the local project.",
+  "Write a specific query the way you would type it into a search engine (include the product name, the version and the exact error text). Read the returned page text before searching again, and do not repeat a query that already returned results. Cite the URLs you relied on in your answer.",
+  COST_GUIDELINE
+];
+var ERROR_TEXT = {
+  daily_cap: "The user's daily free usage is used up. Do not retry; tell the user and continue without this tool.",
+  rolling_cap: "The user's short-term usage limit is reached. Do not retry; continue without this tool.",
+  rate_limited: "Too many calls right now. Wait for the current call to finish, and do not call again in this turn unless needed.",
+  not_found: (library) => `No documentation library matched "${library}". Retry once with the package's exact name, or use web_search.`,
+  not_configured: "This tool is not available on this server. Do not call it again in this session.",
+  upstream_error: "The search provider failed. You may retry once."
+};
+async function post(opts, path, body, label, signal) {
+  try {
+    const timeout = AbortSignal.timeout(30000);
+    const res = await (opts.fetchImpl ?? fetch)(`${opts.baseUrl}${path}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${await opts.getToken()}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: signal ? AbortSignal.any([signal, timeout]) : timeout
+    });
+    if (res.ok)
+      return { ok: true, data: await res.json() };
+    const err = await res.json().catch(() => ({}));
+    const mapped = ERROR_TEXT[err.code ?? ""];
+    if (mapped)
+      return { ok: false, text: typeof mapped === "function" ? mapped(label) : mapped };
+    return { ok: false, text: `Request failed (HTTP ${res.status}): ${err.message ?? "no message"}` };
+  } catch (e) {
+    if (e instanceof Error && e.name === "TimeoutError")
+      return { ok: false, text: "Request timed out after 30 seconds." };
+    return { ok: false, text: `Request failed: ${String(e)}` };
+  }
+}
+var done = (o) => ({ content: [{ type: "text", text: o.text }], details: o.details });
+function createWebToolsExtension(opts) {
+  return {
+    name: "free-pi-web-tools",
+    factory(pi) {
+      pi.registerTool({
+        name: WEB_SEARCH_TOOL_NAME,
+        label: "Web Search",
+        description: "Search the web and return a numbered list of results, each with title, URL, publish date and the page text. Use it for current or recent information that your training data may lack. Each call uses part of the user's daily allowance.",
+        promptSnippet: "Search the web for current information (counts against the user's daily allowance)",
+        promptGuidelines: WEB_SEARCH_GUIDELINES,
+        parameters: _Object_({
+          query: String2({ minLength: 1, maxLength: 500, description: 'Specific query as you would type it into a search engine, e.g. "vite 6 release notes breaking changes"' }),
+          num_results: Optional(Integer({ minimum: 1, maximum: 10, description: "1-10, default 5; use 3 for a quick fact, 8-10 for a survey" }))
+        }),
+        async execute(_id, params, signal) {
+          const r = await post(opts, "/tools/web-search", params, "", signal);
+          if (!r.ok)
+            return done({ text: r.text, details: { ok: false } });
+          const results = r.data.results ?? [];
+          const text = results.length ? `Web results for "${params.query}":
+
+` + results.map((x, i) => `${i + 1}. ${x.title}
+${x.url}${x.published_date ? `
+Published: ${x.published_date}` : ""}
+${x.text}`).join(`
+
+`) : `No results for "${params.query}". Try a broader or differently worded query.`;
+          return done({ text, details: { ok: true, cost_usd: r.data.cost_usd } });
+        }
+      });
+      pi.registerTool({
+        name: DOCS_LOOKUP_TOOL_NAME,
+        label: "Docs Lookup",
+        description: "Look up current documentation for a third-party library, framework or API. Returns the matching library's title and library_id, then documentation text relevant to your query. Use it instead of relying on memory for exact signatures and options. Each call uses part of the user's daily allowance.",
+        promptSnippet: "Look up library/framework documentation before relying on memory (counts against the user's daily allowance)",
+        promptGuidelines: DOCS_LOOKUP_GUIDELINES,
+        parameters: _Object_({
+          library: String2({ minLength: 1, maxLength: 200, description: 'Package or library name, e.g. "next.js", "prisma", "@tanstack/react-query"' }),
+          query: String2({ minLength: 1, maxLength: 500, description: 'One specific question, e.g. "configure middleware matcher for API routes"' }),
+          library_id: Optional(String2({ description: "The library_id printed by an earlier docs_lookup, e.g. /vercel/next.js; skips the name search" }))
+        }),
+        async execute(_id, params, signal) {
+          const r = await post(opts, "/tools/docs", params, params.library, signal);
+          if (!r.ok)
+            return done({ text: r.text, details: { ok: false } });
+          const d = r.data;
+          return done({ text: `${d.title} (library_id: ${d.library_id})
+
+${d.docs}`, details: { ok: true, cost_usd: d.cost_usd } });
+        }
+      });
+    }
+  };
+}
+
 // src/buy-tool.ts
 async function resolveBuyPage(opts) {
   try {
@@ -6126,7 +8801,7 @@ function createDocsToolExtension() {
 // src/todo-view.ts
 var PLAIN_STYLE = { bold: (s) => s, dim: (s) => s, accent: (s) => s, error: (s) => s };
 var GAP = "  ";
-function truncate2(text, max) {
+function truncate(text, max) {
   if (max <= 0)
     return "";
   if ([...text].length <= max)
@@ -6152,19 +8827,19 @@ function widgetLines(todos, width, st = PLAIN_STYLE) {
       ].join(GAP)
     ];
   }
-  const lines = [st.bold(truncate2(header, width))];
+  const lines = [st.bold(truncate(header, width))];
   const open = todos.filter((t) => !t.done);
   if (open.length === 0) {
-    lines.push(st.dim(truncate2("✓ All done", width)));
+    lines.push(st.dim(truncate("✓ All done", width)));
     return lines;
   }
   open.slice(0, 3).forEach((t, i) => {
-    const line = truncate2(`${i === 0 ? "▸" : "○"} ${t.text}`, width);
+    const line = truncate(`${i === 0 ? "▸" : "○"} ${t.text}`, width);
     lines.push(i === 0 ? st.accent(st.bold(line)) : st.dim(line));
   });
   const more = open.length - 3;
   if (more > 0)
-    lines.push(st.dim(truncate2(`+${more} more · /todos for all`, width)));
+    lines.push(st.dim(truncate(`+${more} more · /todos for all`, width)));
   return lines;
 }
 function resultLines(d, st = PLAIN_STYLE) {
@@ -6602,6 +9277,19 @@ function installFooterRightAlign(mode) {
 
 // src/changelog.ts
 var CHANGELOG_HIGHLIGHTS = [
+  {
+    version: "0.4.7",
+    highlights: [
+      "free-pi now updates itself when a new version is required: no more running npx free-pi-cli@latest.",
+      "The ad box redraws at your terminal's width after a resize, and never overflows with wide characters."
+    ]
+  },
+  {
+    version: "0.4.6",
+    highlights: [
+      "Free web search and documentation lookup: the agent can now search the web (web_search) and look up current library docs (docs_lookup). Both run on the free-pi server and count toward your daily allowance."
+    ]
+  },
   {
     version: "0.4.5",
     highlights: [
@@ -6953,12 +9641,12 @@ function updateBannerLines(theme, latest, width) {
   return [
     "",
     border,
-    theme.bold(theme.fg("warning", truncate3(headline, inner))),
-    theme.fg("dim", truncate3(detail, inner)),
+    theme.bold(theme.fg("warning", truncate2(headline, inner))),
+    theme.fg("dim", truncate2(detail, inner)),
     border
   ];
 }
-function truncate3(text, maxWidth) {
+function truncate2(text, maxWidth) {
   if (maxWidth <= 0)
     return "";
   if (text.length <= maxWidth)
@@ -6969,7 +9657,7 @@ function truncate3(text, maxWidth) {
 }
 function headerLines(theme, modelName, expanded, width = Number.POSITIVE_INFINITY, updateLatest) {
   const inner = width - 1;
-  const fit = (plain, styled) => plain.length <= inner ? styled() : theme.fg("dim", truncate3(plain, inner));
+  const fit = (plain, styled) => plain.length <= inner ? styled() : theme.fg("dim", truncate2(plain, inner));
   const titleRest = ` · ${modelName} · ctrl+o for help`;
   const title = fit(`free-pi${titleRest}`, () => `${theme.bold(theme.fg("accent", "free-pi"))}${theme.fg("dim", titleRest)}`);
   const commandLines = COMMANDS.map(({ name, description }) => {
@@ -7182,6 +9870,8 @@ var ALLOWED_TOOL_NAMES = [
   USAGE_TOOL_NAME,
   BUY_TOOL_NAME,
   DOCS_TOOL_NAME,
+  WEB_SEARCH_TOOL_NAME,
+  DOCS_LOOKUP_TOOL_NAME,
   TODO_TOOL_NAME,
   "codemode",
   "tool_search"
@@ -7240,6 +9930,10 @@ function buildRuntimeOptions(opts, sessionId) {
     getToken: () => opts.jwt
   });
   const docsToolExtension = createDocsToolExtension();
+  const webToolsExtension = createWebToolsExtension({
+    baseUrl: opts.baseUrl,
+    getToken: () => opts.jwt
+  });
   const errorNoticeExtension = createErrorNoticeExtension();
   const toolGuardExtension = createToolGuardExtension({
     baseUrl: opts.baseUrl,
@@ -7267,6 +9961,7 @@ function buildRuntimeOptions(opts, sessionId) {
     usageToolExtension,
     buyToolExtension,
     docsToolExtension,
+    webToolsExtension,
     errorNoticeExtension,
     toolGuardExtension,
     commandsExtension,
@@ -7434,6 +10129,62 @@ function createRealSpawn(io = { platform: process.platform, spawnSyncImpl: spawn
   };
 }
 
+// src/relaunch.ts
+import { mkdtempSync, existsSync as existsSync2, rmSync } from "node:fs";
+import { constants as osConstants, tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+var SEMVER = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+var WIN_SAFE_ARG = /^[A-Za-z0-9._:=\/@+,-]+$/;
+async function relaunchViaNpx(latest, deps) {
+  const { env } = deps;
+  if ("FREEPI_NO_AUTO_UPDATE" in env || !deps.autoUpdateEnabled())
+    return;
+  if (env.FREEPI_AUTO_UPDATED)
+    return;
+  const win = deps.platform === "win32";
+  if (win && !deps.argv.every((a) => WIN_SAFE_ARG.test(a)))
+    return;
+  const target = latest && SEMVER.test(latest) ? latest : "latest";
+  const readyDir = mkdtempSync(join5(tmpdir(), "free-pi-relaunch-"));
+  const readyFile = join5(readyDir, "started");
+  try {
+    deps.log(`Updating free-pi to ${target}…`);
+    return await new Promise((resolve) => {
+      let child;
+      try {
+        child = deps.spawn(win ? "npx.cmd" : "npx", ["--yes", `free-pi-cli@${target}`, ...deps.argv], {
+          stdio: "inherit",
+          env: { ...env, FREEPI_AUTO_UPDATED: target, FREEPI_RELAUNCH_READY: readyFile },
+          shell: win
+        });
+      } catch {
+        resolve(undefined);
+        return;
+      }
+      const handlers = win ? [] : [
+        ["SIGINT", () => {}],
+        ["SIGTERM", () => void child.kill("SIGTERM")],
+        ["SIGHUP", () => void child.kill("SIGHUP")]
+      ];
+      for (const [sig, cb] of handlers)
+        deps.proc.on(sig, cb);
+      const done = (code) => {
+        for (const [sig, cb] of handlers)
+          deps.proc.off(sig, cb);
+        resolve(code);
+      };
+      child.on("error", () => done(undefined));
+      child.on("exit", (code, signal) => {
+        const exitCode = code ?? 128 + (signal ? osConstants.signals[signal] ?? 0 : 0);
+        const cancelled = signal === "SIGINT" || signal === "SIGTERM" || signal === "SIGHUP" || exitCode === 130 || exitCode === 143 || exitCode === 129;
+        done(exitCode !== 0 && !cancelled && !existsSync2(readyFile) ? undefined : exitCode);
+      });
+    });
+  } finally {
+    rmSync(readyDir, { recursive: true, force: true });
+  }
+}
+
 // src/auth-flow.ts
 class UnauthorizedError extends Error {
   constructor() {
@@ -7564,12 +10315,12 @@ ${INTRO_TEXT}
 }
 
 // src/whats-new.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 function maybeWhatsNew(cliVersion, agentDir) {
   try {
     const path = getLastSeenVersionPath(agentDir);
-    const lastSeen = existsSync2(path) ? readFileSync2(path, "utf-8").trim() : undefined;
+    const lastSeen = existsSync3(path) ? readFileSync2(path, "utf-8").trim() : undefined;
     writeLastSeen(path, cliVersion);
     if (lastSeen === undefined)
       return;
@@ -7665,6 +10416,9 @@ async function run(deps, argv = process.argv) {
     if (outcome === "updated-exit")
       return 0;
     if (outcome === "blocked") {
+      const relaunched = await deps.relaunchLatest?.(versionCheck.latest);
+      if (relaunched !== undefined)
+        return relaunched;
       deps.log("free-pi-cli is below the required minimum version; update with: npx free-pi-cli@latest");
       return 1;
     }
@@ -7773,6 +10527,11 @@ function resolveCliRealpath() {
   }
 }
 async function main() {
+  if (process.env.FREEPI_RELAUNCH_READY) {
+    try {
+      writeFileSync2(process.env.FREEPI_RELAUNCH_READY, "");
+    } catch {}
+  }
   const command = parseCliArgs(process.argv.slice(2));
   if (command.kind === "version") {
     console.log(versionLine());
@@ -7817,7 +10576,16 @@ ${HELP_TEXT}`);
     launchPi,
     log: (message) => console.log(message),
     checkClientVersion,
-    startGravityPixel: (jwt) => startGravityPixel(jwt, join5(dirname5(agentDir), "gravity")),
+    startGravityPixel: (jwt) => startGravityPixel(jwt, join6(dirname5(agentDir), "gravity")),
+    relaunchLatest: (latest) => relaunchViaNpx(latest, {
+      env: process.env,
+      argv: process.argv.slice(2),
+      platform: process.platform,
+      autoUpdateEnabled: () => readAutoUpdate(getConfigPath()),
+      spawn: (cmd, args, opts) => spawn2(cmd, args, opts),
+      proc: process,
+      log: (message) => console.log(message)
+    }),
     maybeSelfUpdate: (action, latest) => maybeSelfUpdate(action, latest, {
       env: process.env,
       autoUpdateEnabled: () => readAutoUpdate(getConfigPath()),