@qwik.dev/devtools 0.2.4 → 0.2.6

package/dist/ui/node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/opening.qwik.mjs

@@ -1,49 +1,98 @@
+import { whitespace } from "../../../../../hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.qwik.mjs";
 import { siblingAfter, siblingBefore } from "./util/siblings.qwik.mjs";
-import { closing } from "./closing.qwik.mjs";
 import { omission } from "./omission.qwik.mjs";
-import { whitespace } from "../../../../../hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.qwik.mjs";
-const opening = omission({
-  body,
-  colgroup,
-  head,
-  html,
-  tbody
+import { closing } from "./closing.qwik.mjs";
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/opening.js
+/**
+* @import {Element, Parents} from 'hast'
+*/
+var opening = omission({
+	body,
+	colgroup,
+	head,
+	html,
+	tbody
 });
+/**
+* Whether to omit `<html>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function html(node) {
-  const head2 = siblingAfter(node, -1);
-  return !head2 || head2.type !== "comment";
+	const head = siblingAfter(node, -1);
+	return !head || head.type !== "comment";
 }
+/**
+* Whether to omit `<head>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function head(node) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const child2 of node.children) {
-    if (child2.type === "element" && (child2.tagName === "base" || child2.tagName === "title")) {
-      if (seen.has(child2.tagName)) return false;
-      seen.add(child2.tagName);
-    }
-  }
-  const child = node.children[0];
-  return !child || child.type === "element";
+	/** @type {Set<string>} */
+	const seen = /* @__PURE__ */ new Set();
+	for (const child of node.children) if (child.type === "element" && (child.tagName === "base" || child.tagName === "title")) {
+		if (seen.has(child.tagName)) return false;
+		seen.add(child.tagName);
+	}
+	const child = node.children[0];
+	return !child || child.type === "element";
 }
+/**
+* Whether to omit `<body>`.
+*
+* @param {Element} node
+*   Element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function body(node) {
-  const head2 = siblingAfter(node, -1, true);
-  return !head2 || head2.type !== "comment" && !(head2.type === "text" && whitespace(head2.value.charAt(0))) && !(head2.type === "element" && (head2.tagName === "meta" || head2.tagName === "link" || head2.tagName === "script" || head2.tagName === "style" || head2.tagName === "template"));
+	const head = siblingAfter(node, -1, true);
+	return !head || head.type !== "comment" && !(head.type === "text" && whitespace(head.value.charAt(0))) && !(head.type === "element" && (head.tagName === "meta" || head.tagName === "link" || head.tagName === "script" || head.tagName === "style" || head.tagName === "template"));
 }
+/**
+* Whether to omit `<colgroup>`.
+* The spec describes some logic for the opening tag, but it’s easier to
+* implement in the closing tag, to the same effect, so we handle it there
+* instead.
+*
+* @param {Element} node
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function colgroup(node, index, parent) {
-  const previous = siblingBefore(parent, index);
-  const head2 = siblingAfter(node, -1, true);
-  if (parent && previous && previous.type === "element" && previous.tagName === "colgroup" && closing(previous, parent.children.indexOf(previous), parent)) {
-    return false;
-  }
-  return Boolean(head2 && head2.type === "element" && head2.tagName === "col");
+	const previous = siblingBefore(parent, index);
+	const head = siblingAfter(node, -1, true);
+	if (parent && previous && previous.type === "element" && previous.tagName === "colgroup" && closing(previous, parent.children.indexOf(previous), parent)) return false;
+	return Boolean(head && head.type === "element" && head.tagName === "col");
 }
+/**
+* Whether to omit `<tbody>`.
+*
+* @param {Element} node
+*   Element.
+* @param {number | undefined} index
+*   Index of element in parent.
+* @param {Parents | undefined} parent
+*   Parent of element.
+* @returns {boolean}
+*   Whether the opening tag can be omitted.
+*/
 function tbody(node, index, parent) {
-  const previous = siblingBefore(parent, index);
-  const head2 = siblingAfter(node, -1);
-  if (parent && previous && previous.type === "element" && (previous.tagName === "thead" || previous.tagName === "tbody") && closing(previous, parent.children.indexOf(previous), parent)) {
-    return false;
-  }
-  return Boolean(head2 && head2.type === "element" && head2.tagName === "tr");
+	const previous = siblingBefore(parent, index);
+	const head = siblingAfter(node, -1);
+	if (parent && previous && previous.type === "element" && (previous.tagName === "thead" || previous.tagName === "tbody") && closing(previous, parent.children.indexOf(previous), parent)) return false;
+	return Boolean(head && head.type === "element" && head.tagName === "tr");
 }
-export {
-  opening
-};
+//#endregion
+export { opening };

package/dist/ui/node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/util/siblings.qwik.mjs

@@ -1,23 +1,43 @@
 import { whitespace } from "../../../../../../hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.qwik.mjs";
-const siblingAfter = siblings(1);
-const siblingBefore = siblings(-1);
-const emptyChildren = [];
+//#region ../../node_modules/.pnpm/hast-util-to-html@9.0.5/node_modules/hast-util-to-html/lib/omission/util/siblings.js
+/**
+* @import {Parents, RootContent} from 'hast'
+*/
+var siblingAfter = siblings(1);
+var siblingBefore = siblings(-1);
+/** @type {Array<RootContent>} */
+var emptyChildren = [];
+/**
+* Factory to check siblings in a direction.
+*
+* @param {number} increment
+*/
 function siblings(increment) {
-  return sibling;
-  function sibling(parent, index, includeWhitespace) {
-    const siblings2 = parent ? parent.children : emptyChildren;
-    let offset = (index || 0) + increment;
-    let next = siblings2[offset];
-    if (!includeWhitespace) {
-      while (next && whitespace(next)) {
-        offset += increment;
-        next = siblings2[offset];
-      }
-    }
-    return next;
-  }
+	return sibling;
+	/**
+	* Find applicable siblings in a direction.
+	*
+	* @template {Parents} Parent
+	*   Parent type.
+	* @param {Parent | undefined} parent
+	*   Parent.
+	* @param {number | undefined} index
+	*   Index of child in `parent`.
+	* @param {boolean | undefined} [includeWhitespace=false]
+	*   Whether to include whitespace (default: `false`).
+	* @returns {Parent extends {children: Array<infer Child>} ? Child | undefined : never}
+	*   Child of parent.
+	*/
+	function sibling(parent, index, includeWhitespace) {
+		const siblings = parent ? parent.children : emptyChildren;
+		let offset = (index || 0) + increment;
+		let next = siblings[offset];
+		if (!includeWhitespace) while (next && whitespace(next)) {
+			offset += increment;
+			next = siblings[offset];
+		}
+		return next;
+	}
 }
-export {
-  siblingAfter,
-  siblingBefore
-};
+//#endregion
+export { siblingAfter, siblingBefore };

package/dist/ui/node_modules/.pnpm/hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.qwik.mjs

@@ -1,10 +1,28 @@
-const re = /[ \t\n\f\r]/g;
+//#region ../../node_modules/.pnpm/hast-util-whitespace@3.0.0/node_modules/hast-util-whitespace/lib/index.js
+/**
+* @typedef {import('hast').Nodes} Nodes
+*/
+var re = /[ \t\n\f\r]/g;
+/**
+* Check if the given value is *inter-element whitespace*.
+*
+* @param {Nodes | string} thing
+*   Thing to check (`Node` or `string`).
+* @returns {boolean}
+*   Whether the `value` is inter-element whitespace (`boolean`): consisting of
+*   zero or more of space, tab (`\t`), line feed (`\n`), carriage return
+*   (`\r`), or form feed (`\f`); if a node is passed it must be a `Text` node,
+*   whose `value` field is checked.
+*/
 function whitespace(thing) {
-  return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
+	return typeof thing === "object" ? thing.type === "text" ? empty(thing.value) : false : empty(thing);
 }
+/**
+* @param {string} value
+* @returns {boolean}
+*/
 function empty(value) {
-  return value.replace(re, "") === "";
+	return value.replace(re, "") === "";
 }
-export {
-  whitespace
-};
+//#endregion
+export { whitespace };

package/dist/ui/node_modules/.pnpm/html-void-elements@3.0.0/node_modules/html-void-elements/index.qwik.mjs

@@ -1,25 +1,30 @@
-const htmlVoidElements = [
-  "area",
-  "base",
-  "basefont",
-  "bgsound",
-  "br",
-  "col",
-  "command",
-  "embed",
-  "frame",
-  "hr",
-  "image",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr"
+//#region ../../node_modules/.pnpm/html-void-elements@3.0.0/node_modules/html-void-elements/index.js
+/**
+* List of HTML void tag names.
+*
+* @type {Array<string>}
+*/
+var htmlVoidElements = [
+	"area",
+	"base",
+	"basefont",
+	"bgsound",
+	"br",
+	"col",
+	"command",
+	"embed",
+	"frame",
+	"hr",
+	"image",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
 ];
-export {
-  htmlVoidElements
-};
+//#endregion
+export { htmlVoidElements };

package/dist/ui/node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.qwik.mjs

@@ -0,0 +1,7 @@
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/getType.js
+/** Returns the object type of the given payload */
+function getType(payload) {
+	return Object.prototype.toString.call(payload).slice(8, -1);
+}
+//#endregion
+export { getType };

package/dist/ui/node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.qwik.mjs

@@ -0,0 +1,8 @@
+import { getType } from "./getType.qwik.mjs";
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isArray.js
+/** Returns whether the payload is an array */
+function isArray(payload) {
+	return getType(payload) === "Array";
+}
+//#endregion
+export { isArray };

package/dist/ui/node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.qwik.mjs

@@ -0,0 +1,13 @@
+import { getType } from "./getType.qwik.mjs";
+//#region ../../node_modules/.pnpm/is-what@5.5.0/node_modules/is-what/dist/isPlainObject.js
+/**
+* Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+* with other prototypes)
+*/
+function isPlainObject(payload) {
+	if (getType(payload) !== "Object") return false;
+	const prototype = Object.getPrototypeOf(payload);
+	return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+//#endregion
+export { isPlainObject };

package/dist/ui/node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/assert-valid-pattern.qwik.mjs

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+	if (typeof pattern !== "string") throw new TypeError("invalid pattern");
+	if (pattern.length > MAX_PATTERN_LENGTH) throw new TypeError("pattern is too long");
+};
+//#endregion
+export { assertValidPattern };