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

package/dist/ui/node_modules/.pnpm/shiki@4.0.2/node_modules/shiki/dist/wasm.qwik.mjs

@@ -1,6 +1,2 @@
-import { default as default2, default as default3, wasmBinary } from "../../../../@shikijs_engine-oniguruma@4.0.2/node_modules/@shikijs/engine-oniguruma/dist/wasm-inlined.qwik.mjs";
-export {
-  default2 as default,
-  default3 as getWasmInstance,
-  wasmBinary
-};
+import getWasmInstance, { wasmBinary } from "../../../../@shikijs_engine-oniguruma@4.0.2/node_modules/@shikijs/engine-oniguruma/dist/wasm-inlined.qwik.mjs";
+export { getWasmInstance as default, getWasmInstance, wasmBinary };

package/dist/ui/node_modules/.pnpm/space-separated-tokens@2.0.2/node_modules/space-separated-tokens/index.qwik.mjs

@@ -1,6 +1,12 @@
+/**
+* Serialize an array of strings as space separated-tokens.
+*
+* @param {Array<string|number>} values
+*   List of tokens.
+* @returns {string}
+*   Space-separated tokens.
+*/
 function stringify(values) {
-  return values.join(" ").trim();
+	return values.join(" ").trim();
 }
-export {
-  stringify
-};
+export { stringify };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/constant/dangerous.qwik.mjs

@@ -1,13 +1,17 @@
-const dangerous = [
-  "cent",
-  "copy",
-  "divide",
-  "gt",
-  "lt",
-  "not",
-  "para",
-  "times"
+/**
+* List of legacy (that don’t need a trailing `;`) named references which could,
+* depending on what follows them, turn into a different meaning
+*
+* @type {Array<string>}
+*/
+var dangerous = [
+	"cent",
+	"copy",
+	"divide",
+	"gt",
+	"lt",
+	"not",
+	"para",
+	"times"
 ];
-export {
-  dangerous
-};
+export { dangerous };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/core.qwik.mjs

@@ -1,51 +1,76 @@
-const defaultSubsetRegex = /["&'<>`]/g;
-const surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-const controlCharactersRegex = (
-  // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
-  /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
-);
-const regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g;
-const subsetToRegexCache = /* @__PURE__ */ new WeakMap();
+/**
+* @typedef CoreOptions
+* @property {ReadonlyArray<string>} [subset=[]]
+*   Whether to only escape the given subset of characters.
+* @property {boolean} [escapeOnly=false]
+*   Whether to only escape possibly dangerous characters.
+*   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+*
+* @typedef FormatOptions
+* @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
+*   Format strategy.
+*
+* @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
+*/
+var defaultSubsetRegex = /["&'<>`]/g;
+var surrogatePairsRegex = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+var controlCharactersRegex = /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+var regexEscapeRegex = /[|\\{}()[\]^$+*?.]/g;
+/** @type {WeakMap<ReadonlyArray<string>, RegExp>} */
+var subsetToRegexCache = /* @__PURE__ */ new WeakMap();
+/**
+* Encode certain characters in `value`.
+*
+* @param {string} value
+* @param {CoreWithFormatOptions} options
+* @returns {string}
+*/
 function core(value, options) {
-  value = value.replace(
-    options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex,
-    basic
-  );
-  if (options.subset || options.escapeOnly) {
-    return value;
-  }
-  return value.replace(surrogatePairsRegex, surrogate).replace(controlCharactersRegex, basic);
-  function surrogate(pair, index, all) {
-    return options.format(
-      (pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536,
-      all.charCodeAt(index + 2),
-      options
-    );
-  }
-  function basic(character, index, all) {
-    return options.format(
-      character.charCodeAt(0),
-      all.charCodeAt(index + 1),
-      options
-    );
-  }
+	value = value.replace(options.subset ? charactersToExpressionCached(options.subset) : defaultSubsetRegex, basic);
+	if (options.subset || options.escapeOnly) return value;
+	return value.replace(surrogatePairsRegex, surrogate).replace(controlCharactersRegex, basic);
+	/**
+	* @param {string} pair
+	* @param {number} index
+	* @param {string} all
+	*/
+	function surrogate(pair, index, all) {
+		return options.format((pair.charCodeAt(0) - 55296) * 1024 + pair.charCodeAt(1) - 56320 + 65536, all.charCodeAt(index + 2), options);
+	}
+	/**
+	* @param {string} character
+	* @param {number} index
+	* @param {string} all
+	*/
+	function basic(character, index, all) {
+		return options.format(character.charCodeAt(0), all.charCodeAt(index + 1), options);
+	}
 }
+/**
+* A wrapper function that caches the result of `charactersToExpression` with a WeakMap.
+* This can improve performance when tooling calls `charactersToExpression` repeatedly
+* with the same subset.
+*
+* @param {ReadonlyArray<string>} subset
+* @returns {RegExp}
+*/
 function charactersToExpressionCached(subset) {
-  let cached = subsetToRegexCache.get(subset);
-  if (!cached) {
-    cached = charactersToExpression(subset);
-    subsetToRegexCache.set(subset, cached);
-  }
-  return cached;
+	let cached = subsetToRegexCache.get(subset);
+	if (!cached) {
+		cached = charactersToExpression(subset);
+		subsetToRegexCache.set(subset, cached);
+	}
+	return cached;
 }
+/**
+* @param {ReadonlyArray<string>} subset
+* @returns {RegExp}
+*/
 function charactersToExpression(subset) {
-  const groups = [];
-  let index = -1;
-  while (++index < subset.length) {
-    groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
-  }
-  return new RegExp("(?:" + groups.join("|") + ")", "g");
+	/** @type {Array<string>} */
+	const groups = [];
+	let index = -1;
+	while (++index < subset.length) groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
+	return new RegExp("(?:" + groups.join("|") + ")", "g");
 }
-export {
-  core
-};
+export { core };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/index.qwik.mjs

@@ -1,8 +1,20 @@
 import { core } from "./core.qwik.mjs";
 import { formatSmart } from "./util/format-smart.qwik.mjs";
+/**
+* @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
+* @typedef {import('./core.js').CoreOptions} LightOptions
+*/
+/**
+* Encode special characters in `value`.
+*
+* @param {string} value
+*   Value to encode.
+* @param {Options} [options]
+*   Configuration.
+* @returns {string}
+*   Encoded value.
+*/
 function stringifyEntities(value, options) {
-  return core(value, Object.assign({ format: formatSmart }, options));
+	return core(value, Object.assign({ format: formatSmart }, options));
 }
-export {
-  stringifyEntities
-};
+export { stringifyEntities };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/format-smart.qwik.mjs

@@ -1,25 +1,39 @@
 import { toHexadecimal } from "./to-hexadecimal.qwik.mjs";
 import { toDecimal } from "./to-decimal.qwik.mjs";
 import { toNamed } from "./to-named.qwik.mjs";
+/**
+* @typedef FormatSmartOptions
+* @property {boolean} [useNamedReferences=false]
+*   Prefer named character references (`&`) where possible.
+* @property {boolean} [useShortestReferences=false]
+*   Prefer the shortest possible reference, if that results in less bytes.
+*   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
+* @property {boolean} [omitOptionalSemicolons=false]
+*   Whether to omit semicolons when possible.
+*   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
+*   Omitting semicolons is possible for certain named and numeric references in some cases.
+* @property {boolean} [attribute=false]
+*   Create character references which don’t fail in attributes.
+*   **Note**: `attribute` only applies when operating dangerously with
+*   `omitOptionalSemicolons: true`.
+*/
+/**
+* Configurable ways to encode a character yielding pretty or small results.
+*
+* @param {number} code
+* @param {number} next
+* @param {FormatSmartOptions} options
+* @returns {string}
+*/
 function formatSmart(code, next, options) {
-  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
-  let named;
-  if (options.useNamedReferences || options.useShortestReferences) {
-    named = toNamed(
-      code,
-      next,
-      options.omitOptionalSemicolons,
-      options.attribute
-    );
-  }
-  if ((options.useShortestReferences || !named) && options.useShortestReferences) {
-    const decimal = toDecimal(code, next, options.omitOptionalSemicolons);
-    if (decimal.length < numeric.length) {
-      numeric = decimal;
-    }
-  }
-  return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
+	let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
+	/** @type {string|undefined} */
+	let named;
+	if (options.useNamedReferences || options.useShortestReferences) named = toNamed(code, next, options.omitOptionalSemicolons, options.attribute);
+	if ((options.useShortestReferences || !named) && options.useShortestReferences) {
+		const decimal = toDecimal(code, next, options.omitOptionalSemicolons);
+		if (decimal.length < numeric.length) numeric = decimal;
+	}
+	return named && (!options.useShortestReferences || named.length < numeric.length) ? named : numeric;
 }
-export {
-  formatSmart
-};
+export { formatSmart };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-decimal.qwik.mjs

@@ -1,8 +1,14 @@
-const decimalRegex = /\d/;
+var decimalRegex = /\d/;
+/**
+* Configurable ways to encode characters as decimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toDecimal(code, next, omit) {
-  const value = "&#" + String(code);
-  return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+	const value = "&#" + String(code);
+	return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
-export {
-  toDecimal
-};
+export { toDecimal };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-hexadecimal.qwik.mjs

@@ -1,8 +1,14 @@
-const hexadecimalRegex = /[\dA-Fa-f]/;
+var hexadecimalRegex = /[\dA-Fa-f]/;
+/**
+* Configurable ways to encode characters as hexadecimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toHexadecimal(code, next, omit) {
-  const value = "&#x" + code.toString(16).toUpperCase();
-  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+	const value = "&#x" + code.toString(16).toUpperCase();
+	return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
-export {
-  toHexadecimal
-};
+export { toHexadecimal };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-named.qwik.mjs

@@ -1,27 +1,34 @@
 import { characterEntitiesLegacy } from "../../../../../character-entities-legacy@3.0.0/node_modules/character-entities-legacy/index.qwik.mjs";
 import { characterEntitiesHtml4 } from "../../../../../character-entities-html4@2.1.0/node_modules/character-entities-html4/index.qwik.mjs";
 import { dangerous } from "../constant/dangerous.qwik.mjs";
-const own = {}.hasOwnProperty;
-const characters = {};
-let key;
-for (key in characterEntitiesHtml4) {
-  if (own.call(characterEntitiesHtml4, key)) {
-    characters[characterEntitiesHtml4[key]] = key;
-  }
-}
-const notAlphanumericRegex = /[^\dA-Za-z]/;
+var own = {}.hasOwnProperty;
+/**
+* `characterEntitiesHtml4` but inverted.
+*
+* @type {Record<string, string>}
+*/
+var characters = {};
+/** @type {string} */
+var key;
+for (key in characterEntitiesHtml4) if (own.call(characterEntitiesHtml4, key)) characters[characterEntitiesHtml4[key]] = key;
+var notAlphanumericRegex = /[^\dA-Za-z]/;
+/**
+* Configurable ways to encode characters as named references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @param {boolean|undefined} attribute
+* @returns {string}
+*/
 function toNamed(code, next, omit, attribute) {
-  const character = String.fromCharCode(code);
-  if (own.call(characters, character)) {
-    const name = characters[character];
-    const value = "&" + name;
-    if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) {
-      return value;
-    }
-    return value + ";";
-  }
-  return "";
+	const character = String.fromCharCode(code);
+	if (own.call(characters, character)) {
+		const name = characters[character];
+		const value = "&" + name;
+		if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) return value;
+		return value + ";";
+	}
+	return "";
 }
-export {
-  toNamed
-};
+export { toNamed };

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

@@ -0,0 +1,25 @@
+async function getViteClient(base = "/", warning = true) {
+	try {
+		const url = `${base}@vite/client`;
+		const res = await fetch(url);
+		if ((await res.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"`);
+	}
+}
+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 hot = (await getViteClient(base, false))?.createHotContext(path);
+		if (hot) return hot;
+	}
+	console.error("[vite-hot-client] Failed to import vite client, tried with:", bases);
+}
+export { getViteClient, guessBasesFromPathname, tryCreateHotContext };

package/dist/ui/node_modules/.pnpm/zwitch@2.0.4/node_modules/zwitch/index.qwik.mjs

@@ -1,22 +1,104 @@
-const own = {}.hasOwnProperty;
+/**
+* @callback Handler
+*   Handle a value, with a certain ID field set to a certain value.
+*   The ID field is passed to `zwitch`, and it’s value is this function’s
+*   place on the `handlers` record.
+* @param {...any} parameters
+*   Arbitrary parameters passed to the zwitch.
+*   The first will be an object with a certain ID field set to a certain value.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback UnknownHandler
+*   Handle values that do have a certain ID field, but it’s set to a value
+*   that is not listed in the `handlers` record.
+* @param {unknown} value
+*   An object with a certain ID field set to an unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {any}
+*   Anything!
+*/
+/**
+* @callback InvalidHandler
+*   Handle values that do not have a certain ID field.
+* @param {unknown} value
+*   Any unknown value.
+* @param {...any} rest
+*   Arbitrary parameters passed to the zwitch.
+* @returns {void|null|undefined|never}
+*   This should crash or return nothing.
+*/
+/**
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @typedef Options
+*   Configuration (required).
+* @property {Invalid} [invalid]
+*   Handler to use for invalid values.
+* @property {Unknown} [unknown]
+*   Handler to use for unknown values.
+* @property {Handlers} [handlers]
+*   Handlers to use.
+*/
+var own = {}.hasOwnProperty;
+/**
+* Handle values based on a field.
+*
+* @template {InvalidHandler} [Invalid=InvalidHandler]
+* @template {UnknownHandler} [Unknown=UnknownHandler]
+* @template {Record<string, Handler>} [Handlers=Record<string, Handler>]
+* @param {string} key
+*   Field to switch on.
+* @param {Options<Invalid, Unknown, Handlers>} [options]
+*   Configuration (required).
+* @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}
+*/
 function zwitch(key, options) {
-  const settings = options || {};
-  function one(value, ...parameters) {
-    let fn = one.invalid;
-    const handlers = one.handlers;
-    if (value && own.call(value, key)) {
-      const id = String(value[key]);
-      fn = own.call(handlers, id) ? handlers[id] : one.unknown;
-    }
-    if (fn) {
-      return fn.call(this, value, ...parameters);
-    }
-  }
-  one.handlers = settings.handlers || {};
-  one.invalid = settings.invalid;
-  one.unknown = settings.unknown;
-  return one;
+	const settings = options || {};
+	/**
+	* Handle one value.
+	*
+	* Based on the bound `key`, a respective handler will be called.
+	* If `value` is not an object, or doesn’t have a `key` property, the special
+	* “invalid” handler will be called.
+	* If `value` has an unknown `key`, the special “unknown” handler will be
+	* called.
+	*
+	* All arguments, and the context object, are passed through to the handler,
+	* and it’s result is returned.
+	*
+	* @this {unknown}
+	*   Any context object.
+	* @param {unknown} [value]
+	*   Any value.
+	* @param {...unknown} parameters
+	*   Arbitrary parameters passed to the zwitch.
+	* @property {Handler} invalid
+	*   Handle for values that do not have a certain ID field.
+	* @property {Handler} unknown
+	*   Handle values that do have a certain ID field, but it’s set to a value
+	*   that is not listed in the `handlers` record.
+	* @property {Handlers} handlers
+	*   Record of handlers.
+	* @returns {unknown}
+	*   Anything.
+	*/
+	function one(value, ...parameters) {
+		/** @type {Handler|undefined} */
+		let fn = one.invalid;
+		const handlers = one.handlers;
+		if (value && own.call(value, key)) {
+			const id = String(value[key]);
+			fn = own.call(handlers, id) ? handlers[id] : one.unknown;
+		}
+		if (fn) return fn.call(this, value, ...parameters);
+	}
+	one.handlers = settings.handlers || {};
+	one.invalid = settings.invalid;
+	one.unknown = settings.unknown;
+	return one;
 }
-export {
-  zwitch
-};
+export { zwitch };

package/dist/ui/packages/devtools/kit/src/overlay-paths.qwik.mjs

@@ -1,25 +1,16 @@
 function normalizeExcludePathname(pathname) {
-  const trimmed = pathname.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const prefixed = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-  return prefixed.length > 1 ? prefixed.replace(/\/+$/, "") : prefixed;
+	const trimmed = pathname.trim();
+	if (!trimmed) return "";
+	const prefixed = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+	return prefixed.length > 1 ? prefixed.replace(/\/+$/, "") : prefixed;
 }
 function normalizeExcludePathnames(pathnames) {
-  if (!pathnames) {
-    return [];
-  }
-  return [
-    ...new Set(pathnames.map(normalizeExcludePathname).filter(Boolean))
-  ];
+	if (!pathnames) return [];
+	return [...new Set(pathnames.map(normalizeExcludePathname).filter(Boolean))];
 }
 function isExcludedPathname(pathname, excludePathnames) {
-  return normalizeExcludePathnames(excludePathnames).some((excludedPathname) => {
-    return pathname === excludedPathname || pathname.startsWith(excludedPathname + "/");
-  });
+	return normalizeExcludePathnames(excludePathnames).some((excludedPathname) => {
+		return pathname === excludedPathname || pathname.startsWith(excludedPathname + "/");
+	});
 }
-export {
-  isExcludedPathname,
-  normalizeExcludePathnames
-};
+export { isExcludedPathname, normalizeExcludePathnames };