@qwik.dev/devtools 0.2.7 → 0.3.0-beta.3

package/dist/ui/node_modules/.pnpm/regex-recursion@6.0.2/node_modules/regex-recursion/src/index.qwik.mjs

@@ -0,0 +1,250 @@
+import { hasUnescaped, Context, getGroupContents, forEachUnescaped, replaceUnescaped } from "../../../../regex-utilities@2.3.0/node_modules/regex-utilities/src/index.qwik.mjs";
+const r = String.raw;
+const gRToken = r`\\g<(?<gRNameOrNum>[^>&]+)&R=(?<gRDepth>[^>]+)>`;
+const recursiveToken = r`\(\?R=(?<rDepth>[^\)]+)\)|${gRToken}`;
+const namedCaptureDelim = r`\(\?<(?![=!])(?<captureName>[^>]+)>`;
+const captureDelim = r`${namedCaptureDelim}|(?<unnamed>\()(?!\?)`;
+const token = new RegExp(r`${namedCaptureDelim}|${recursiveToken}|\(\?|\\?.`, "gsu");
+const overlappingRecursionMsg = "Cannot use multiple overlapping recursions";
+function recursion(pattern, data) {
+  const { hiddenCaptures, mode } = {
+    hiddenCaptures: [],
+    mode: "plugin",
+    ...data
+  };
+  let captureTransfers = data?.captureTransfers ?? /* @__PURE__ */ new Map();
+  if (!new RegExp(recursiveToken, "su").test(pattern)) {
+    return {
+      pattern,
+      captureTransfers,
+      hiddenCaptures
+    };
+  }
+  if (mode === "plugin" && hasUnescaped(pattern, r`\(\?\(DEFINE\)`, Context.DEFAULT)) {
+    throw new Error("DEFINE groups cannot be used with recursion");
+  }
+  const addedHiddenCaptures = [];
+  const hasNumberedBackref = hasUnescaped(pattern, r`\\[1-9]`, Context.DEFAULT);
+  const groupContentsStartPos = /* @__PURE__ */ new Map();
+  const openGroups = [];
+  let hasRecursed = false;
+  let numCharClassesOpen = 0;
+  let numCapturesPassed = 0;
+  let match;
+  token.lastIndex = 0;
+  while (match = token.exec(pattern)) {
+    const { 0: m, groups: { captureName, rDepth, gRNameOrNum, gRDepth } } = match;
+    if (m === "[") {
+      numCharClassesOpen++;
+    } else if (!numCharClassesOpen) {
+      if (rDepth) {
+        assertMaxInBounds(rDepth);
+        if (hasRecursed) {
+          throw new Error(overlappingRecursionMsg);
+        }
+        if (hasNumberedBackref) {
+          throw new Error(
+            // When used in `external` mode by transpilers other than Regex+, backrefs might have
+            // gone through conversion from named to numbered, so avoid a misleading error
+            `${mode === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with global recursion`
+          );
+        }
+        const left = pattern.slice(0, match.index);
+        const right = pattern.slice(token.lastIndex);
+        if (hasUnescaped(right, recursiveToken, Context.DEFAULT)) {
+          throw new Error(overlappingRecursionMsg);
+        }
+        const reps = +rDepth - 1;
+        pattern = makeRecursive(
+          left,
+          right,
+          reps,
+          false,
+          hiddenCaptures,
+          addedHiddenCaptures,
+          numCapturesPassed
+        );
+        captureTransfers = mapCaptureTransfers(
+          captureTransfers,
+          left,
+          reps,
+          addedHiddenCaptures.length,
+          0,
+          numCapturesPassed
+        );
+        break;
+      } else if (gRNameOrNum) {
+        assertMaxInBounds(gRDepth);
+        let isWithinReffedGroup = false;
+        for (const g of openGroups) {
+          if (g.name === gRNameOrNum || g.num === +gRNameOrNum) {
+            isWithinReffedGroup = true;
+            if (g.hasRecursedWithin) {
+              throw new Error(overlappingRecursionMsg);
+            }
+            break;
+          }
+        }
+        if (!isWithinReffedGroup) {
+          throw new Error(r`Recursive \g cannot be used outside the referenced group "${mode === "external" ? gRNameOrNum : r`\g<${gRNameOrNum}&R=${gRDepth}>`}"`);
+        }
+        const startPos = groupContentsStartPos.get(gRNameOrNum);
+        const groupContents = getGroupContents(pattern, startPos);
+        if (hasNumberedBackref && hasUnescaped(groupContents, r`${namedCaptureDelim}|\((?!\?)`, Context.DEFAULT)) {
+          throw new Error(
+            // When used in `external` mode by transpilers other than Regex+, backrefs might have
+            // gone through conversion from named to numbered, so avoid a misleading error
+            `${mode === "external" ? "Backrefs" : "Numbered backrefs"} cannot be used with recursion of capturing groups`
+          );
+        }
+        const groupContentsLeft = pattern.slice(startPos, match.index);
+        const groupContentsRight = groupContents.slice(groupContentsLeft.length + m.length);
+        const numAddedHiddenCapturesPreExpansion = addedHiddenCaptures.length;
+        const reps = +gRDepth - 1;
+        const expansion = makeRecursive(
+          groupContentsLeft,
+          groupContentsRight,
+          reps,
+          true,
+          hiddenCaptures,
+          addedHiddenCaptures,
+          numCapturesPassed
+        );
+        captureTransfers = mapCaptureTransfers(
+          captureTransfers,
+          groupContentsLeft,
+          reps,
+          addedHiddenCaptures.length - numAddedHiddenCapturesPreExpansion,
+          numAddedHiddenCapturesPreExpansion,
+          numCapturesPassed
+        );
+        const pre = pattern.slice(0, startPos);
+        const post = pattern.slice(startPos + groupContents.length);
+        pattern = `${pre}${expansion}${post}`;
+        token.lastIndex += expansion.length - m.length - groupContentsLeft.length - groupContentsRight.length;
+        openGroups.forEach((g) => g.hasRecursedWithin = true);
+        hasRecursed = true;
+      } else if (captureName) {
+        numCapturesPassed++;
+        groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);
+        groupContentsStartPos.set(captureName, token.lastIndex);
+        openGroups.push({
+          num: numCapturesPassed,
+          name: captureName
+        });
+      } else if (m[0] === "(") {
+        const isUnnamedCapture = m === "(";
+        if (isUnnamedCapture) {
+          numCapturesPassed++;
+          groupContentsStartPos.set(String(numCapturesPassed), token.lastIndex);
+        }
+        openGroups.push(isUnnamedCapture ? { num: numCapturesPassed } : {});
+      } else if (m === ")") {
+        openGroups.pop();
+      }
+    } else if (m === "]") {
+      numCharClassesOpen--;
+    }
+  }
+  hiddenCaptures.push(...addedHiddenCaptures);
+  return {
+    pattern,
+    captureTransfers,
+    hiddenCaptures
+  };
+}
+function assertMaxInBounds(max) {
+  const errMsg = `Max depth must be integer between 2 and 100; used ${max}`;
+  if (!/^[1-9]\d*$/.test(max)) {
+    throw new Error(errMsg);
+  }
+  max = +max;
+  if (max < 2 || max > 100) {
+    throw new Error(errMsg);
+  }
+}
+function makeRecursive(left, right, reps, isSubpattern, hiddenCaptures, addedHiddenCaptures, numCapturesPassed) {
+  const namesInRecursed = /* @__PURE__ */ new Set();
+  if (isSubpattern) {
+    forEachUnescaped(left + right, namedCaptureDelim, ({ groups: { captureName } }) => {
+      namesInRecursed.add(captureName);
+    }, Context.DEFAULT);
+  }
+  const rest = [
+    reps,
+    isSubpattern ? namesInRecursed : null,
+    hiddenCaptures,
+    addedHiddenCaptures,
+    numCapturesPassed
+  ];
+  return `${left}${repeatWithDepth(`(?:${left}`, "forward", ...rest)}(?:)${repeatWithDepth(`${right})`, "backward", ...rest)}${right}`;
+}
+function repeatWithDepth(pattern, direction, reps, namesInRecursed, hiddenCaptures, addedHiddenCaptures, numCapturesPassed) {
+  const startNum = 2;
+  const getDepthNum = (i) => direction === "forward" ? i + startNum : reps - i + startNum - 1;
+  let result = "";
+  for (let i = 0; i < reps; i++) {
+    const depthNum = getDepthNum(i);
+    result += replaceUnescaped(
+      pattern,
+      r`${captureDelim}|\\k<(?<backref>[^>]+)>`,
+      ({ 0: m, groups: { captureName, unnamed, backref } }) => {
+        if (backref && namesInRecursed && !namesInRecursed.has(backref)) {
+          return m;
+        }
+        const suffix = `_$${depthNum}`;
+        if (unnamed || captureName) {
+          const addedCaptureNum = numCapturesPassed + addedHiddenCaptures.length + 1;
+          addedHiddenCaptures.push(addedCaptureNum);
+          incrementIfAtLeast(hiddenCaptures, addedCaptureNum);
+          return unnamed ? m : `(?<${captureName}${suffix}>`;
+        }
+        return r`\k<${backref}${suffix}>`;
+      },
+      Context.DEFAULT
+    );
+  }
+  return result;
+}
+function incrementIfAtLeast(arr, threshold) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= threshold) {
+      arr[i]++;
+    }
+  }
+}
+function mapCaptureTransfers(captureTransfers, left, reps, numCapturesAddedInExpansion, numAddedHiddenCapturesPreExpansion, numCapturesPassed) {
+  if (captureTransfers.size && numCapturesAddedInExpansion) {
+    let numCapturesInLeft = 0;
+    forEachUnescaped(left, captureDelim, () => numCapturesInLeft++, Context.DEFAULT);
+    const recursionDelimCaptureNum = numCapturesPassed - numCapturesInLeft + numAddedHiddenCapturesPreExpansion;
+    const newCaptureTransfers = /* @__PURE__ */ new Map();
+    captureTransfers.forEach((from, to) => {
+      const numCapturesInRight = (numCapturesAddedInExpansion - numCapturesInLeft * reps) / reps;
+      const numCapturesAddedInLeft = numCapturesInLeft * reps;
+      const newTo = to > recursionDelimCaptureNum + numCapturesInLeft ? to + numCapturesAddedInExpansion : to;
+      const newFrom = [];
+      for (const f of from) {
+        if (f <= recursionDelimCaptureNum) {
+          newFrom.push(f);
+        } else if (f > recursionDelimCaptureNum + numCapturesInLeft + numCapturesInRight) {
+          newFrom.push(f + numCapturesAddedInExpansion);
+        } else if (f <= recursionDelimCaptureNum + numCapturesInLeft) {
+          for (let i = 0; i <= reps; i++) {
+            newFrom.push(f + numCapturesInLeft * i);
+          }
+        } else {
+          for (let i = 0; i <= reps; i++) {
+            newFrom.push(f + numCapturesAddedInLeft + numCapturesInRight * i);
+          }
+        }
+      }
+      newCaptureTransfers.set(newTo, newFrom);
+    });
+    return newCaptureTransfers;
+  }
+  return captureTransfers;
+}
+export {
+  recursion
+};

package/dist/ui/node_modules/.pnpm/regex-utilities@2.3.0/node_modules/regex-utilities/src/index.qwik.mjs

@@ -0,0 +1,98 @@
+const Context = Object.freeze({
+  DEFAULT: "DEFAULT",
+  CHAR_CLASS: "CHAR_CLASS"
+});
+function replaceUnescaped(expression, needle, replacement, context) {
+  const re = new RegExp(String.raw`${needle}|(?<$skip>\[\^?|\\?.)`, "gsu");
+  const negated = [false];
+  let numCharClassesOpen = 0;
+  let result = "";
+  for (const match of expression.matchAll(re)) {
+    const { 0: m, groups: { $skip } } = match;
+    if (!$skip && (!context || context === Context.DEFAULT === !numCharClassesOpen)) {
+      if (replacement instanceof Function) {
+        result += replacement(match, {
+          context: numCharClassesOpen ? Context.CHAR_CLASS : Context.DEFAULT,
+          negated: negated[negated.length - 1]
+        });
+      } else {
+        result += replacement;
+      }
+      continue;
+    }
+    if (m[0] === "[") {
+      numCharClassesOpen++;
+      negated.push(m[1] === "^");
+    } else if (m === "]" && numCharClassesOpen) {
+      numCharClassesOpen--;
+      negated.pop();
+    }
+    result += m;
+  }
+  return result;
+}
+function forEachUnescaped(expression, needle, callback, context) {
+  replaceUnescaped(expression, needle, callback, context);
+}
+function execUnescaped(expression, needle, pos = 0, context) {
+  if (!new RegExp(needle, "su").test(expression)) {
+    return null;
+  }
+  const re = new RegExp(`${needle}|(?<$skip>\\\\?.)`, "gsu");
+  re.lastIndex = pos;
+  let numCharClassesOpen = 0;
+  let match;
+  while (match = re.exec(expression)) {
+    const { 0: m, groups: { $skip } } = match;
+    if (!$skip && (!context || context === Context.DEFAULT === !numCharClassesOpen)) {
+      return match;
+    }
+    if (m === "[") {
+      numCharClassesOpen++;
+    } else if (m === "]" && numCharClassesOpen) {
+      numCharClassesOpen--;
+    }
+    if (re.lastIndex == match.index) {
+      re.lastIndex++;
+    }
+  }
+  return null;
+}
+function hasUnescaped(expression, needle, context) {
+  return !!execUnescaped(expression, needle, 0, context);
+}
+function getGroupContents(expression, contentsStartPos) {
+  const token = /\\?./gsu;
+  token.lastIndex = contentsStartPos;
+  let contentsEndPos = expression.length;
+  let numCharClassesOpen = 0;
+  let numGroupsOpen = 1;
+  let match;
+  while (match = token.exec(expression)) {
+    const [m] = match;
+    if (m === "[") {
+      numCharClassesOpen++;
+    } else if (!numCharClassesOpen) {
+      if (m === "(") {
+        numGroupsOpen++;
+      } else if (m === ")") {
+        numGroupsOpen--;
+        if (!numGroupsOpen) {
+          contentsEndPos = match.index;
+          break;
+        }
+      }
+    } else if (m === "]") {
+      numCharClassesOpen--;
+    }
+  }
+  return expression.slice(contentsStartPos, contentsEndPos);
+}
+export {
+  Context,
+  execUnescaped,
+  forEachUnescaped,
+  getGroupContents,
+  hasUnescaped,
+  replaceUnescaped
+};

package/dist/ui/node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/atomic.qwik.mjs

@@ -0,0 +1,174 @@
+import { incrementIfAtLeast, noncapturingDelim, spliceStr } from "./utils-internals.qwik.mjs";
+import { replaceUnescaped, Context } from "../../../../regex-utilities@2.3.0/node_modules/regex-utilities/src/index.qwik.mjs";
+const atomicPluginToken = new RegExp(String.raw`(?<noncapturingStart>${noncapturingDelim})|(?<capturingStart>\((?:\?<[^>]+>)?)|\\?.`, "gsu");
+function atomic(expression, data) {
+  const hiddenCaptures = data?.hiddenCaptures ?? [];
+  let captureTransfers = data?.captureTransfers ?? /* @__PURE__ */ new Map();
+  if (!/\(\?>/.test(expression)) {
+    return {
+      pattern: expression,
+      captureTransfers,
+      hiddenCaptures
+    };
+  }
+  const aGDelim = "(?>";
+  const emulatedAGDelim = "(?:(?=(";
+  const captureNumMap = [0];
+  const addedHiddenCaptures = [];
+  let numCapturesBeforeAG = 0;
+  let numAGs = 0;
+  let aGPos = NaN;
+  let hasProcessedAG;
+  do {
+    hasProcessedAG = false;
+    let numCharClassesOpen = 0;
+    let numGroupsOpenInAG = 0;
+    let inAG = false;
+    let match;
+    atomicPluginToken.lastIndex = Number.isNaN(aGPos) ? 0 : aGPos + emulatedAGDelim.length;
+    while (match = atomicPluginToken.exec(expression)) {
+      const { 0: m, index, groups: { capturingStart, noncapturingStart } } = match;
+      if (m === "[") {
+        numCharClassesOpen++;
+      } else if (!numCharClassesOpen) {
+        if (m === aGDelim && !inAG) {
+          aGPos = index;
+          inAG = true;
+        } else if (inAG && noncapturingStart) {
+          numGroupsOpenInAG++;
+        } else if (capturingStart) {
+          if (inAG) {
+            numGroupsOpenInAG++;
+          } else {
+            numCapturesBeforeAG++;
+            captureNumMap.push(numCapturesBeforeAG + numAGs);
+          }
+        } else if (m === ")" && inAG) {
+          if (!numGroupsOpenInAG) {
+            numAGs++;
+            const addedCaptureNum = numCapturesBeforeAG + numAGs;
+            expression = `${expression.slice(0, aGPos)}${emulatedAGDelim}${expression.slice(aGPos + aGDelim.length, index)}))<$$${addedCaptureNum}>)${expression.slice(index + 1)}`;
+            hasProcessedAG = true;
+            addedHiddenCaptures.push(addedCaptureNum);
+            incrementIfAtLeast(hiddenCaptures, addedCaptureNum);
+            if (captureTransfers.size) {
+              const newCaptureTransfers = /* @__PURE__ */ new Map();
+              captureTransfers.forEach((from, to) => {
+                newCaptureTransfers.set(
+                  to >= addedCaptureNum ? to + 1 : to,
+                  from.map((f) => f >= addedCaptureNum ? f + 1 : f)
+                );
+              });
+              captureTransfers = newCaptureTransfers;
+            }
+            break;
+          }
+          numGroupsOpenInAG--;
+        }
+      } else if (m === "]") {
+        numCharClassesOpen--;
+      }
+    }
+  } while (hasProcessedAG);
+  hiddenCaptures.push(...addedHiddenCaptures);
+  expression = replaceUnescaped(
+    expression,
+    String.raw`\\(?<backrefNum>[1-9]\d*)|<\$\$(?<wrappedBackrefNum>\d+)>`,
+    ({ 0: m, groups: { backrefNum, wrappedBackrefNum } }) => {
+      if (backrefNum) {
+        const bNum = +backrefNum;
+        if (bNum > captureNumMap.length - 1) {
+          throw new Error(`Backref "${m}" greater than number of captures`);
+        }
+        return `\\${captureNumMap[bNum]}`;
+      }
+      return `\\${wrappedBackrefNum}`;
+    },
+    Context.DEFAULT
+  );
+  return {
+    pattern: expression,
+    captureTransfers,
+    hiddenCaptures
+  };
+}
+const baseQuantifier = String.raw`(?:[?*+]|\{\d+(?:,\d*)?\})`;
+const possessivePluginToken = new RegExp(String.raw`
+\\(?: \d+
+  | c[A-Za-z]
+  | [gk]<[^>]+>
+  | [pPu]\{[^\}]+\}
+  | u[A-Fa-f\d]{4}
+  | x[A-Fa-f\d]{2}
+  )
+| \((?: \? (?: [:=!>]
+  | <(?:[=!]|[^>]+>)
+  | [A-Za-z\-]+:
+  | \(DEFINE\)
+  ))?
+| (?<qBase>${baseQuantifier})(?<qMod>[?+]?)(?<invalidQ>[?*+\{]?)
+| \\?.
+`.replace(/\s+/g, ""), "gsu");
+function possessive(expression) {
+  if (!new RegExp(`${baseQuantifier}\\+`).test(expression)) {
+    return {
+      pattern: expression
+    };
+  }
+  const openGroupIndices = [];
+  let lastGroupIndex = null;
+  let lastCharClassIndex = null;
+  let lastToken = "";
+  let numCharClassesOpen = 0;
+  let match;
+  possessivePluginToken.lastIndex = 0;
+  while (match = possessivePluginToken.exec(expression)) {
+    const { 0: m, index, groups: { qBase, qMod, invalidQ } } = match;
+    if (m === "[") {
+      if (!numCharClassesOpen) {
+        lastCharClassIndex = index;
+      }
+      numCharClassesOpen++;
+    } else if (m === "]") {
+      if (numCharClassesOpen) {
+        numCharClassesOpen--;
+      } else {
+        lastCharClassIndex = null;
+      }
+    } else if (!numCharClassesOpen) {
+      if (qMod === "+" && lastToken && !lastToken.startsWith("(")) {
+        if (invalidQ) {
+          throw new Error(`Invalid quantifier "${m}"`);
+        }
+        let charsAdded = -1;
+        if (/^\{\d+\}$/.test(qBase)) {
+          expression = spliceStr(expression, index + qBase.length, qMod, "");
+        } else {
+          if (lastToken === ")" || lastToken === "]") {
+            const nodeIndex = lastToken === ")" ? lastGroupIndex : lastCharClassIndex;
+            if (nodeIndex === null) {
+              throw new Error(`Invalid unmatched "${lastToken}"`);
+            }
+            expression = `${expression.slice(0, nodeIndex)}(?>${expression.slice(nodeIndex, index)}${qBase})${expression.slice(index + m.length)}`;
+          } else {
+            expression = `${expression.slice(0, index - lastToken.length)}(?>${lastToken}${qBase})${expression.slice(index + m.length)}`;
+          }
+          charsAdded += 4;
+        }
+        possessivePluginToken.lastIndex += charsAdded;
+      } else if (m[0] === "(") {
+        openGroupIndices.push(index);
+      } else if (m === ")") {
+        lastGroupIndex = openGroupIndices.length ? openGroupIndices.pop() : null;
+      }
+    }
+    lastToken = m;
+  }
+  return {
+    pattern: expression
+  };
+}
+export {
+  atomic,
+  possessive
+};

package/dist/ui/node_modules/.pnpm/regex@6.1.0/node_modules/regex/src/utils-internals.qwik.mjs

@@ -0,0 +1,16 @@
+const noncapturingDelim = String.raw`\(\?(?:[:=!>A-Za-z\-]|<[=!]|\(DEFINE\))`;
+function incrementIfAtLeast(arr, threshold) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] >= threshold) {
+      arr[i]++;
+    }
+  }
+}
+function spliceStr(str, pos, oldValue, newValue) {
+  return str.slice(0, pos) + newValue + str.slice(pos + oldValue.length);
+}
+export {
+  incrementIfAtLeast,
+  noncapturingDelim,
+  spliceStr
+};

package/dist/ui/node_modules/.pnpm/shiki@4.0.2/node_modules/shiki/dist/bundle-full.qwik.mjs

@@ -1,25 +1,61 @@
-import { bundledLanguages } from "./langs-bundle-full-DfKZStlK.qwik.mjs";
-import { bundledThemes } from "./themes.qwik.mjs";
-import { engine_oniguruma_exports } from "./engine-oniguruma.qwik.mjs";
-import "../../../../@shikijs_types@4.0.2/node_modules/@shikijs/types/dist/index.qwik.mjs";
-import "../../../../@shikijs_primitive@4.0.2/node_modules/@shikijs/primitive/dist/index.qwik.mjs";
+import { t as __exportAll } from "./chunk-CtajNgzt.qwik.mjs";
+import { t as engine_oniguruma_exports } from "./engine-oniguruma.qwik.mjs";
+import { t as bundledLanguages, i as bundledLanguagesInfo, r as bundledLanguagesBase, n as bundledLanguagesAlias } from "./langs-bundle-full-DfKZStlK.qwik.mjs";
+import { bundledThemes, bundledThemesInfo } from "./themes.qwik.mjs";
 import { createBundledHighlighter, createSingletonShorthands, guessEmbeddedLanguages } from "../../../../@shikijs_core@4.0.2/node_modules/@shikijs/core/dist/index.qwik.mjs";
-//#region ../../node_modules/.pnpm/shiki@4.0.2/node_modules/shiki/dist/bundle-full.mjs
-/**
-* Initiate a highlighter instance and load the specified languages and themes.
-* Later it can be used synchronously to highlight code.
-*
-* Importing this function will bundle all languages and themes.
-* @see https://shiki.style/guide/bundles#shiki-bundle-full
-*
-* For granular control over the bundle, check:
-* @see https://shiki.style/guide/bundles#fine-grained-bundle
-*/
-var createHighlighter = /* @__PURE__ */ createBundledHighlighter({
-	langs: bundledLanguages,
-	themes: bundledThemes,
-	engine: () => (0, engine_oniguruma_exports.createOnigurumaEngine)(import("./wasm.qwik.mjs"))
+import { addClassToHast, createHighlighterCore, createPositionConverter, flatTokenVariants, getTokenStyleObject, hastToHtml, makeSingletonHighlighter, splitToken, splitTokens, stringifyTokenStyle, tokenizeAnsiWithTheme, tokensToHast, transformerDecorations } from "../../../../@shikijs_core@4.0.2/node_modules/@shikijs/core/dist/index.qwik.mjs";
+var bundle_full_exports = /* @__PURE__ */ __exportAll({
+  bundledLanguages: () => bundledLanguages,
+  bundledLanguagesAlias: () => bundledLanguagesAlias,
+  bundledLanguagesBase: () => bundledLanguagesBase,
+  bundledLanguagesInfo: () => bundledLanguagesInfo,
+  bundledThemes: () => bundledThemes,
+  bundledThemesInfo: () => bundledThemesInfo,
+  codeToHast: () => codeToHast,
+  codeToHtml: () => codeToHtml,
+  codeToTokens: () => codeToTokens,
+  codeToTokensBase: () => codeToTokensBase,
+  codeToTokensWithThemes: () => codeToTokensWithThemes,
+  createHighlighter: () => createHighlighter,
+  getLastGrammarState: () => getLastGrammarState,
+  getSingletonHighlighter: () => getSingletonHighlighter
 });
-var { codeToHtml, codeToHast, codeToTokens, codeToTokensBase, codeToTokensWithThemes, getSingletonHighlighter, getLastGrammarState } = /* @__PURE__ */ createSingletonShorthands(createHighlighter, { guessEmbeddedLanguages });
-//#endregion
-export { createHighlighter };
+const createHighlighter = /* @__PURE__ */ createBundledHighlighter({
+  langs: bundledLanguages,
+  themes: bundledThemes,
+  engine: () => (0, engine_oniguruma_exports.createOnigurumaEngine)(import("./wasm.qwik.mjs"))
+});
+const { codeToHtml, codeToHast, codeToTokens, codeToTokensBase, codeToTokensWithThemes, getSingletonHighlighter, getLastGrammarState } = /* @__PURE__ */ createSingletonShorthands(createHighlighter, { guessEmbeddedLanguages });
+export {
+  addClassToHast,
+  bundledLanguages,
+  bundledLanguagesAlias,
+  bundledLanguagesBase,
+  bundledLanguagesInfo,
+  bundledThemes,
+  bundledThemesInfo,
+  codeToHast,
+  codeToHtml,
+  codeToTokens,
+  codeToTokensBase,
+  codeToTokensWithThemes,
+  createBundledHighlighter,
+  createHighlighter,
+  createHighlighterCore,
+  createPositionConverter,
+  createSingletonShorthands,
+  flatTokenVariants,
+  getLastGrammarState,
+  getSingletonHighlighter,
+  getTokenStyleObject,
+  guessEmbeddedLanguages,
+  hastToHtml,
+  makeSingletonHighlighter,
+  splitToken,
+  splitTokens,
+  stringifyTokenStyle,
+  bundle_full_exports as t,
+  tokenizeAnsiWithTheme,
+  tokensToHast,
+  transformerDecorations
+};

package/dist/ui/node_modules/.pnpm/shiki@4.0.2/node_modules/shiki/dist/chunk-CtajNgzt.qwik.mjs

@@ -1,27 +1,36 @@
-//#region ../../node_modules/.pnpm/shiki@4.0.2/node_modules/shiki/dist/chunk-CtajNgzt.mjs
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
+  let target = {};
+  for (var name in all) {
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true
+    });
+  }
+  {
+    __defProp(target, Symbol.toStringTag, { value: "Module" });
+  }
+  return target;
 };
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp.call(to, key) && key !== except) {
+        __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+      }
+    }
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
+export {
+  __reExport as n,
+  __exportAll as t
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-//#endregion
-export { __exportAll, __reExport };