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

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

@@ -1,2 +1,6 @@
-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 };
+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
+};

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

@@ -1,14 +1,6 @@
-//#region ../../node_modules/.pnpm/space-separated-tokens@2.0.2/node_modules/space-separated-tokens/index.js
-/**
-* 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();
 }
-//#endregion
-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,19 +1,13 @@
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/constant/dangerous.js
-/**
-* 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"
+const dangerous = [
+  "cent",
+  "copy",
+  "divide",
+  "gt",
+  "lt",
+  "not",
+  "para",
+  "times"
 ];
-//#endregion
-export { dangerous };
+export {
+  dangerous
+};

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

@@ -1,78 +1,51 @@
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/core.js
-/**
-* @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}
-*/
+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();
 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);
-	/**
-	* @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);
-	}
+  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
+    );
+  }
 }
-/**
-* 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) {
-	/** @type {Array<string>} */
-	const groups = [];
-	let index = -1;
-	while (++index < subset.length) groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
-	return new RegExp("(?:" + groups.join("|") + ")", "g");
+  const groups = [];
+  let index = -1;
+  while (++index < subset.length) {
+    groups.push(subset[index].replace(regexEscapeRegex, "\\$&"));
+  }
+  return new RegExp("(?:" + groups.join("|") + ")", "g");
 }
-//#endregion
-export { core };
+export {
+  core
+};

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

@@ -1,22 +1,8 @@
 import { core } from "./core.qwik.mjs";
 import { formatSmart } from "./util/format-smart.qwik.mjs";
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/index.js
-/**
-* @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));
 }
-//#endregion
-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,41 +1,25 @@
 import { toHexadecimal } from "./to-hexadecimal.qwik.mjs";
 import { toDecimal } from "./to-decimal.qwik.mjs";
 import { toNamed } from "./to-named.qwik.mjs";
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/format-smart.js
-/**
-* @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);
-	/** @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;
+  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;
 }
-//#endregion
-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,16 +1,8 @@
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-decimal.js
-var decimalRegex = /\d/;
-/**
-* Configurable ways to encode characters as decimal references.
-*
-* @param {number} code
-* @param {number} next
-* @param {boolean|undefined} omit
-* @returns {string}
-*/
+const decimalRegex = /\d/;
 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 + ";";
 }
-//#endregion
-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,16 +1,8 @@
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-hexadecimal.js
-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}
-*/
+const hexadecimalRegex = /[\dA-Fa-f]/;
 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 + ";";
 }
-//#endregion
-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,36 +1,27 @@
 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";
-//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-named.js
-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}
-*/
+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]/;
 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 "";
 }
-//#endregion
-export { toNamed };
+export {
+  toNamed
+};

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

@@ -0,0 +1,35 @@
+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
+};

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

@@ -1,106 +1,22 @@
-//#region ../../node_modules/.pnpm/zwitch@2.0.4/node_modules/zwitch/index.js
-/**
-* @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>}}
-*/
+const own = {}.hasOwnProperty;
 function zwitch(key, options) {
-	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;
+  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;
 }
-//#endregion
-export { zwitch };
+export {
+  zwitch
+};

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

@@ -0,0 +1,25 @@
+function normalizeExcludePathname(pathname) {
+  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))
+  ];
+}
+function isExcludedPathname(pathname, excludePathnames) {
+  return normalizeExcludePathnames(excludePathnames).some((excludedPathname) => {
+    return pathname === excludedPathname || pathname.startsWith(excludedPathname + "/");
+  });
+}
+export {
+  isExcludedPathname,
+  normalizeExcludePathnames
+};