@qwik.dev/devtools 0.2.5 → 0.2.7

package/dist/ui/node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.qwik.mjs

@@ -0,0 +1,49 @@
+//#region ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+	const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+	const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+	const r = ma !== null && mb != null && range(ma, mb, str);
+	return r && {
+		start: r[0],
+		end: r[1],
+		pre: str.slice(0, r[0]),
+		body: str.slice(r[0] + ma.length, r[1]),
+		post: str.slice(r[1] + mb.length)
+	};
+};
+var maybeMatch = (reg, str) => {
+	const m = str.match(reg);
+	return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+	let begs, beg, left, right = void 0, result;
+	let ai = str.indexOf(a);
+	let bi = str.indexOf(b, ai + 1);
+	let i = ai;
+	if (ai >= 0 && bi > 0) {
+		if (a === b) return [ai, bi];
+		begs = [];
+		left = str.length;
+		while (i >= 0 && !result) {
+			if (i === ai) {
+				begs.push(i);
+				ai = str.indexOf(a, i + 1);
+			} else if (begs.length === 1) {
+				const r = begs.pop();
+				if (r !== void 0) result = [r, bi];
+			} else {
+				beg = begs.pop();
+				if (beg !== void 0 && beg < left) {
+					left = beg;
+					right = bi;
+				}
+				bi = str.indexOf(b, i + 1);
+			}
+			i = ai < bi && ai >= 0 ? ai : bi;
+		}
+		if (begs.length && right !== void 0) result = [left, right];
+	}
+	return result;
+};
+//#endregion
+export { balanced };

package/dist/ui/node_modules/.pnpm/birpc@4.0.0/node_modules/birpc/dist/index.qwik.mjs

@@ -0,0 +1,200 @@
+//#region ../../node_modules/.pnpm/birpc@4.0.0/node_modules/birpc/dist/index.mjs
+var TYPE_REQUEST = "q";
+var TYPE_RESPONSE = "s";
+function createPromiseWithResolvers() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		}),
+		resolve,
+		reject
+	};
+}
+var random = Math.random.bind(Math);
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+	let id = "";
+	let i = size;
+	while (i--) id += urlAlphabet[random() * 64 | 0];
+	return id;
+}
+var DEFAULT_TIMEOUT = 6e4;
+var defaultSerialize = (i) => i;
+var defaultDeserialize = defaultSerialize;
+var { clearTimeout, setTimeout } = globalThis;
+function createBirpc($functions, options) {
+	const { post, on, off = () => {}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+	let $closed = false;
+	const _rpcPromiseMap = /* @__PURE__ */ new Map();
+	let _promiseInit;
+	let rpc;
+	async function _call(method, args, event, optional) {
+		if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+		const req = {
+			m: method,
+			a: args,
+			t: TYPE_REQUEST
+		};
+		if (optional) req.o = true;
+		const send = async (_req) => post(serialize(_req));
+		if (event) {
+			await send(req);
+			return;
+		}
+		if (_promiseInit) try {
+			await _promiseInit;
+		} finally {
+			_promiseInit = void 0;
+		}
+		let { promise, resolve, reject } = createPromiseWithResolvers();
+		const id = nanoid();
+		req.i = id;
+		let timeoutId;
+		async function handler(newReq = req) {
+			if (timeout >= 0) {
+				timeoutId = setTimeout(() => {
+					try {
+						if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+					} catch (e) {
+						reject(e);
+					}
+					_rpcPromiseMap.delete(id);
+				}, timeout);
+				if (typeof timeoutId === "object") timeoutId = timeoutId.unref?.();
+			}
+			_rpcPromiseMap.set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method
+			});
+			await send(newReq);
+			return promise;
+		}
+		try {
+			if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+			else await handler();
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		} finally {
+			clearTimeout(timeoutId);
+			_rpcPromiseMap.delete(id);
+		}
+		return promise;
+	}
+	const builtinMethods = {
+		$call: (method, ...args) => _call(method, args, false),
+		$callOptional: (method, ...args) => _call(method, args, false, true),
+		$callEvent: (method, ...args) => _call(method, args, true),
+		$callRaw: (options$1) => _call(options$1.method, options$1.args, options$1.event, options$1.optional),
+		$rejectPendingCalls,
+		get $closed() {
+			return $closed;
+		},
+		get $meta() {
+			return options.meta;
+		},
+		$close,
+		$functions
+	};
+	if (proxify) rpc = new Proxy({}, { get(_, method) {
+		if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+		if (method === "then" && !eventNames.includes("then") && !("then" in $functions)) return void 0;
+		const sendEvent = (...args) => _call(method, args, true);
+		if (eventNames.includes(method)) {
+			sendEvent.asEvent = sendEvent;
+			return sendEvent;
+		}
+		const sendCall = (...args) => _call(method, args, false);
+		sendCall.asEvent = sendEvent;
+		return sendCall;
+	} });
+	else rpc = builtinMethods;
+	function $close(customError) {
+		$closed = true;
+		_rpcPromiseMap.forEach(({ reject, method }) => {
+			const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+			if (customError) {
+				customError.cause ?? (customError.cause = error);
+				return reject(customError);
+			}
+			reject(error);
+		});
+		_rpcPromiseMap.clear();
+		off(onMessage);
+	}
+	function $rejectPendingCalls(handler) {
+		const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject }) => {
+			if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+			return handler({
+				method,
+				reject
+			});
+		});
+		_rpcPromiseMap.clear();
+		return handlerResults;
+	}
+	async function onMessage(data, ...extra) {
+		let msg;
+		try {
+			msg = deserialize(data);
+		} catch (e) {
+			if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+			return;
+		}
+		if (msg.t === TYPE_REQUEST) {
+			const { m: method, a: args, o: optional } = msg;
+			let result, error;
+			let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+			if (optional) fn || (fn = () => void 0);
+			if (!fn) error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+			else try {
+				result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+			} catch (e) {
+				error = e;
+			}
+			if (msg.i) {
+				if (error && options.onFunctionError) {
+					if (options.onFunctionError.call(rpc, error, method, args) === true) return;
+				}
+				if (!error) try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						r: result
+					}), ...extra);
+					return;
+				} catch (e) {
+					error = e;
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+				try {
+					await post(serialize({
+						t: TYPE_RESPONSE,
+						i: msg.i,
+						e: error
+					}), ...extra);
+				} catch (e) {
+					if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+				}
+			}
+		} else {
+			const { i: ack, r: result, e: error } = msg;
+			const promise = _rpcPromiseMap.get(ack);
+			if (promise) {
+				clearTimeout(promise.timeoutId);
+				if (error) promise.reject(error);
+				else promise.resolve(result);
+			}
+			_rpcPromiseMap.delete(ack);
+		}
+	}
+	_promiseInit = on(onMessage);
+	return rpc;
+}
+//#endregion
+export { createBirpc };

package/dist/ui/node_modules/.pnpm/brace-expansion@5.0.4/node_modules/brace-expansion/dist/esm/index.qwik.mjs

@@ -0,0 +1,143 @@
+import { balanced } from "../../../../../balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.qwik.mjs";
+//#region ../../node_modules/.pnpm/brace-expansion@5.0.4/node_modules/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\\./g;
+var EXPANSION_MAX = 1e5;
+function numeric(str) {
+	return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+	return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+	return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+/**
+* Basically just str.split(","), but handling cases
+* where we have nested braced sections, which should be
+* treated as individual members, like {a,{b,c},d}
+*/
+function parseCommaParts(str) {
+	if (!str) return [""];
+	const parts = [];
+	const m = balanced("{", "}", str);
+	if (!m) return str.split(",");
+	const { pre, body, post } = m;
+	const p = pre.split(",");
+	p[p.length - 1] += "{" + body + "}";
+	const postParts = parseCommaParts(post);
+	if (post.length) {
+		p[p.length - 1] += postParts.shift();
+		p.push.apply(p, postParts);
+	}
+	parts.push.apply(parts, p);
+	return parts;
+}
+function expand(str, options = {}) {
+	if (!str) return [];
+	const { max = EXPANSION_MAX } = options;
+	if (str.slice(0, 2) === "{}") str = "\\{\\}" + str.slice(2);
+	return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+}
+function embrace(str) {
+	return "{" + str + "}";
+}
+function isPadded(el) {
+	return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+	return i <= y;
+}
+function gte(i, y) {
+	return i >= y;
+}
+function expand_(str, max, isTop) {
+	/** @type {string[]} */
+	const expansions = [];
+	const m = balanced("{", "}", str);
+	if (!m) return [str];
+	const pre = m.pre;
+	const post = m.post.length ? expand_(m.post, max, false) : [""];
+	if (/\$$/.test(m.pre)) for (let k = 0; k < post.length && k < max; k++) {
+		const expansion = pre + "{" + m.body + "}" + post[k];
+		expansions.push(expansion);
+	}
+	else {
+		const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+		const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+		const isSequence = isNumericSequence || isAlphaSequence;
+		const isOptions = m.body.indexOf(",") >= 0;
+		if (!isSequence && !isOptions) {
+			if (m.post.match(/,(?!,).*\}/)) {
+				str = m.pre + "{" + m.body + escClose + m.post;
+				return expand_(str, max, true);
+			}
+			return [str];
+		}
+		let n;
+		if (isSequence) n = m.body.split(/\.\./);
+		else {
+			n = parseCommaParts(m.body);
+			if (n.length === 1 && n[0] !== void 0) {
+				n = expand_(n[0], max, false).map(embrace);
+				/* c8 ignore start */
+				if (n.length === 1) return post.map((p) => m.pre + n[0] + p);
+			}
+		}
+		let N;
+		if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+			const x = numeric(n[0]);
+			const y = numeric(n[1]);
+			const width = Math.max(n[0].length, n[1].length);
+			let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+			let test = lte;
+			if (y < x) {
+				incr *= -1;
+				test = gte;
+			}
+			const pad = n.some(isPadded);
+			N = [];
+			for (let i = x; test(i, y); i += incr) {
+				let c;
+				if (isAlphaSequence) {
+					c = String.fromCharCode(i);
+					if (c === "\\") c = "";
+				} else {
+					c = String(i);
+					if (pad) {
+						const need = width - c.length;
+						if (need > 0) {
+							const z = new Array(need + 1).join("0");
+							if (i < 0) c = "-" + z + c.slice(1);
+							else c = z + c;
+						}
+					}
+				}
+				N.push(c);
+			}
+		} else {
+			N = [];
+			for (let j = 0; j < n.length; j++) N.push.apply(N, expand_(n[j], max, false));
+		}
+		for (let j = 0; j < N.length; j++) for (let k = 0; k < post.length && expansions.length < max; k++) {
+			const expansion = pre + N[j] + post[k];
+			if (!isTop || isSequence || expansion) expansions.push(expansion);
+		}
+	}
+	return expansions;
+}
+//#endregion
+export { expand };

package/dist/ui/node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.qwik.mjs

@@ -1,16 +1,24 @@
+//#region ../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js
+/**
+* Count how often a character (or substring) is used in a string.
+*
+* @param {string} value
+*   Value to search in.
+* @param {string} character
+*   Character (or substring) to look for.
+* @return {number}
+*   Number of times `character` occurred in `value`.
+*/
 function ccount(value, character) {
-  const source = String(value);
-  if (typeof character !== "string") {
-    throw new TypeError("Expected character");
-  }
-  let count = 0;
-  let index = source.indexOf(character);
-  while (index !== -1) {
-    count++;
-    index = source.indexOf(character, index + character.length);
-  }
-  return count;
+	const source = String(value);
+	if (typeof character !== "string") throw new TypeError("Expected character");
+	let count = 0;
+	let index = source.indexOf(character);
+	while (index !== -1) {
+		count++;
+		index = source.indexOf(character, index + character.length);
+	}
+	return count;
 }
-export {
-  ccount
-};
+//#endregion
+export { ccount };