@qwik.dev/devtools 0.3.0-beta.3 → 2.0.0-beta.43

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

@@ -1,250 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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/index.qwik.mjs

@@ -1,47 +0,0 @@
-import { n as __reExport, t as __exportAll } from "./chunk-CtajNgzt.qwik.mjs";
-import { i as bundledLanguagesInfo, r as bundledLanguagesBase, n as bundledLanguagesAlias, t as bundledLanguages } from "./langs-bundle-full-DfKZStlK.qwik.mjs";
-import { bundledThemesInfo, bundledThemes } from "./themes.qwik.mjs";
-import { t as bundle_full_exports, getSingletonHighlighter, getLastGrammarState, createHighlighter, codeToTokensWithThemes, codeToTokensBase, codeToTokens, codeToHtml, codeToHast } from "./bundle-full.qwik.mjs";
-import { loadWasm, createOnigurumaEngine } from "../../../../@shikijs_engine-oniguruma@4.0.2/node_modules/@shikijs/engine-oniguruma/dist/index.qwik.mjs";
-import { defaultJavaScriptRegexConstructor, createJavaScriptRegexEngine } from "../../../../@shikijs_engine-javascript@4.0.2/node_modules/@shikijs/engine-javascript/dist/engine-compile.qwik.mjs";
-var src_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,
-  createJavaScriptRegexEngine: () => createJavaScriptRegexEngine,
-  createOnigurumaEngine: () => createOnigurumaEngine,
-  defaultJavaScriptRegexConstructor: () => defaultJavaScriptRegexConstructor,
-  getLastGrammarState: () => getLastGrammarState,
-  getSingletonHighlighter: () => getSingletonHighlighter,
-  loadWasm: () => loadWasm
-});
-__reExport(src_exports, bundle_full_exports);
-export {
-  bundledLanguages,
-  bundledLanguagesAlias,
-  bundledLanguagesBase,
-  bundledLanguagesInfo,
-  bundledThemes,
-  bundledThemesInfo,
-  codeToHast,
-  codeToHtml,
-  codeToTokens,
-  codeToTokensBase,
-  codeToTokensWithThemes,
-  createHighlighter,
-  createJavaScriptRegexEngine,
-  createOnigurumaEngine,
-  defaultJavaScriptRegexConstructor,
-  getLastGrammarState,
-  getSingletonHighlighter,
-  loadWasm
-};

package/dist/ui/node_modules/.pnpm/vite-hot-client@2.1.0_vite@7.3.5_@types_node@24.10.0_jiti@2.6.1_lightningcss@1.33.0_terser@5.46.0_tsx@4.21.0_yaml@2.8.3_/node_modules/vite-hot-client/dist/index.qwik.mjs

@@ -1,35 +0,0 @@
-async function getViteClient(base = "/", warning = true) {
-  try {
-    const url = `${base}@vite/client`;
-    const res = await fetch(url);
-    const text = await res.text();
-    if (text.startsWith("<") || !res.headers.get("content-type")?.includes("javascript"))
-      throw new Error("Not javascript");
-    return await import(
-      /* @vite-ignore */
-      url
-    );
-  } catch {
-    if (warning)
-      console.error(`[vite-hot-client] Failed to import "${base}@vite/client"`);
-  }
-  return void 0;
-}
-function guessBasesFromPathname(pathname = window.location.pathname) {
-  return pathname.split("/").map((i, idx, arr) => arr.slice(0, idx + 1).join("/") || "/");
-}
-async function tryCreateHotContext(path = "/___", bases) {
-  bases = bases ?? guessBasesFromPathname();
-  for (const base of bases) {
-    const viteClient = await getViteClient(base, false);
-    const hot = viteClient?.createHotContext(path);
-    if (hot)
-      return hot;
-  }
-  console.error("[vite-hot-client] Failed to import vite client, tried with:", bases);
-}
-export {
-  getViteClient,
-  guessBasesFromPathname,
-  tryCreateHotContext
-};