@noma.to/qwik-testing-library 1.0.4 → 1.2.0

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/index.qwik.cjs

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const array = require("./array.qwik.cjs");
+const typedarray = require("./typedarray.qwik.cjs");
+const date = require("./date.qwik.cjs");
+const _function = require("./function.qwik.cjs");
+const map = require("./map.qwik.cjs");
+const number = require("./number.qwik.cjs");
+const bigint = require("./bigint.qwik.cjs");
+const regexp = require("./regexp.qwik.cjs");
+const set = require("./set.qwik.cjs");
+const string = require("./string.qwik.cjs");
+const symbol = require("./symbol.qwik.cjs");
+const promise = require("./promise.qwik.cjs");
+const _class = require("./class.qwik.cjs");
+const object = require("./object.qwik.cjs");
+const _arguments = require("./arguments.qwik.cjs");
+const error = require("./error.qwik.cjs");
+const html = require("./html.qwik.cjs");
+const helpers = require("./helpers.qwik.cjs");
+const symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
+const chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect";
+let nodeInspect = false;
+try {
+  const nodeUtil = require("util");
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect = false;
+}
+const constructorMap = /* @__PURE__ */ new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+  undefined: (value, options) => options.stylize("undefined", "undefined"),
+  null: (value, options) => options.stylize("null", "null"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  number,
+  Number: number,
+  bigint,
+  BigInt: bigint,
+  string,
+  String: string,
+  function: _function,
+  Function: _function,
+  symbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: symbol,
+  Array: array,
+  Date: date,
+  Map: map,
+  Set: set,
+  RegExp: regexp,
+  Promise: promise,
+  // WeakSet, WeakMap are totally opaque to us
+  WeakSet: (value, options) => options.stylize("WeakSet{…}", "special"),
+  WeakMap: (value, options) => options.stylize("WeakMap{…}", "special"),
+  Arguments: _arguments,
+  Int8Array: typedarray,
+  Uint8Array: typedarray,
+  Uint8ClampedArray: typedarray,
+  Int16Array: typedarray,
+  Uint16Array: typedarray,
+  Int32Array: typedarray,
+  Uint32Array: typedarray,
+  Float32Array: typedarray,
+  Float64Array: typedarray,
+  Generator: () => "",
+  DataView: () => "",
+  ArrayBuffer: () => "",
+  Error: error,
+  HTMLCollection: html.inspectHTMLCollection,
+  NodeList: html.inspectHTMLCollection
+};
+const inspectCustom = (value, options, type) => {
+  if (chaiInspect in value && typeof value[chaiInspect] === "function") {
+    return value[chaiInspect](options);
+  }
+  if (nodeInspect && nodeInspect in value && typeof value[nodeInspect] === "function") {
+    return value[nodeInspect](options.depth, options);
+  }
+  if ("inspect" in value && typeof value.inspect === "function") {
+    return value.inspect(options.depth, options);
+  }
+  if ("constructor" in value && constructorMap.has(value.constructor)) {
+    return constructorMap.get(value.constructor)(value, options);
+  }
+  if (stringTagMap[type]) {
+    return stringTagMap[type](value, options);
+  }
+  return "";
+};
+const toString = Object.prototype.toString;
+function inspect(value, opts = {}) {
+  const options = helpers.normaliseOptions(opts, inspect);
+  const { customInspect } = options;
+  let type = value === null ? "null" : typeof value;
+  if (type === "object") {
+    type = toString.call(value).slice(8, -1);
+  }
+  if (type in baseTypesMap) {
+    return baseTypesMap[type](value, options);
+  }
+  if (customInspect && value) {
+    const output = inspectCustom(value, options, type);
+    if (output) {
+      if (typeof output === "string")
+        return output;
+      return inspect(output, options);
+    }
+  }
+  const proto = value ? Object.getPrototypeOf(value) : false;
+  if (proto === Object.prototype || proto === null) {
+    return object(value, options);
+  }
+  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+    return html.default(value, options);
+  }
+  if ("constructor" in value) {
+    if (value.constructor !== Object) {
+      return _class(value, options);
+    }
+    return object(value, options);
+  }
+  if (value === Object(value)) {
+    return object(value, options);
+  }
+  return options.stylize(String(value), type);
+}
+exports.default = inspect;
+exports.inspect = inspect;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/index.qwik.mjs

@@ -0,0 +1,130 @@
+import inspectArray from "./array.qwik.mjs";
+import inspectTypedArray from "./typedarray.qwik.mjs";
+import inspectDate from "./date.qwik.mjs";
+import inspectFunction from "./function.qwik.mjs";
+import inspectMap from "./map.qwik.mjs";
+import inspectNumber from "./number.qwik.mjs";
+import inspectBigInt from "./bigint.qwik.mjs";
+import inspectRegExp from "./regexp.qwik.mjs";
+import inspectSet from "./set.qwik.mjs";
+import inspectString from "./string.qwik.mjs";
+import inspectSymbol from "./symbol.qwik.mjs";
+import inspectPromise from "./promise.qwik.mjs";
+import inspectClass from "./class.qwik.mjs";
+import inspectObject from "./object.qwik.mjs";
+import inspectArguments from "./arguments.qwik.mjs";
+import inspectObject$1 from "./error.qwik.mjs";
+import inspectHTML, { inspectHTMLCollection } from "./html.qwik.mjs";
+import { normaliseOptions } from "./helpers.qwik.mjs";
+const symbolsSupported = typeof Symbol === "function" && typeof Symbol.for === "function";
+const chaiInspect = symbolsSupported ? Symbol.for("chai/inspect") : "@@chai/inspect";
+let nodeInspect = false;
+try {
+  const nodeUtil = require("util");
+  nodeInspect = nodeUtil.inspect ? nodeUtil.inspect.custom : false;
+} catch (noNodeInspect) {
+  nodeInspect = false;
+}
+const constructorMap = /* @__PURE__ */ new WeakMap();
+const stringTagMap = {};
+const baseTypesMap = {
+  undefined: (value, options) => options.stylize("undefined", "undefined"),
+  null: (value, options) => options.stylize("null", "null"),
+  boolean: (value, options) => options.stylize(String(value), "boolean"),
+  Boolean: (value, options) => options.stylize(String(value), "boolean"),
+  number: inspectNumber,
+  Number: inspectNumber,
+  bigint: inspectBigInt,
+  BigInt: inspectBigInt,
+  string: inspectString,
+  String: inspectString,
+  function: inspectFunction,
+  Function: inspectFunction,
+  symbol: inspectSymbol,
+  // A Symbol polyfill will return `Symbol` not `symbol` from typedetect
+  Symbol: inspectSymbol,
+  Array: inspectArray,
+  Date: inspectDate,
+  Map: inspectMap,
+  Set: inspectSet,
+  RegExp: inspectRegExp,
+  Promise: inspectPromise,
+  // WeakSet, WeakMap are totally opaque to us
+  WeakSet: (value, options) => options.stylize("WeakSet{…}", "special"),
+  WeakMap: (value, options) => options.stylize("WeakMap{…}", "special"),
+  Arguments: inspectArguments,
+  Int8Array: inspectTypedArray,
+  Uint8Array: inspectTypedArray,
+  Uint8ClampedArray: inspectTypedArray,
+  Int16Array: inspectTypedArray,
+  Uint16Array: inspectTypedArray,
+  Int32Array: inspectTypedArray,
+  Uint32Array: inspectTypedArray,
+  Float32Array: inspectTypedArray,
+  Float64Array: inspectTypedArray,
+  Generator: () => "",
+  DataView: () => "",
+  ArrayBuffer: () => "",
+  Error: inspectObject$1,
+  HTMLCollection: inspectHTMLCollection,
+  NodeList: inspectHTMLCollection
+};
+const inspectCustom = (value, options, type) => {
+  if (chaiInspect in value && typeof value[chaiInspect] === "function") {
+    return value[chaiInspect](options);
+  }
+  if (nodeInspect && nodeInspect in value && typeof value[nodeInspect] === "function") {
+    return value[nodeInspect](options.depth, options);
+  }
+  if ("inspect" in value && typeof value.inspect === "function") {
+    return value.inspect(options.depth, options);
+  }
+  if ("constructor" in value && constructorMap.has(value.constructor)) {
+    return constructorMap.get(value.constructor)(value, options);
+  }
+  if (stringTagMap[type]) {
+    return stringTagMap[type](value, options);
+  }
+  return "";
+};
+const toString = Object.prototype.toString;
+function inspect(value, opts = {}) {
+  const options = normaliseOptions(opts, inspect);
+  const { customInspect } = options;
+  let type = value === null ? "null" : typeof value;
+  if (type === "object") {
+    type = toString.call(value).slice(8, -1);
+  }
+  if (type in baseTypesMap) {
+    return baseTypesMap[type](value, options);
+  }
+  if (customInspect && value) {
+    const output = inspectCustom(value, options, type);
+    if (output) {
+      if (typeof output === "string")
+        return output;
+      return inspect(output, options);
+    }
+  }
+  const proto = value ? Object.getPrototypeOf(value) : false;
+  if (proto === Object.prototype || proto === null) {
+    return inspectObject(value, options);
+  }
+  if (value && typeof HTMLElement === "function" && value instanceof HTMLElement) {
+    return inspectHTML(value, options);
+  }
+  if ("constructor" in value) {
+    if (value.constructor !== Object) {
+      return inspectClass(value, options);
+    }
+    return inspectObject(value, options);
+  }
+  if (value === Object(value)) {
+    return inspectObject(value, options);
+  }
+  return options.stylize(String(value), type);
+}
+export {
+  inspect as default,
+  inspect
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/map.qwik.cjs

@@ -0,0 +1,25 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+function inspectMapEntry([key, value], options) {
+  options.truncate -= 4;
+  key = options.inspect(key, options);
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key} => ${value}`;
+}
+function mapToEntries(map) {
+  const entries = [];
+  map.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+}
+function inspectMap(map, options) {
+  const size = map.size - 1;
+  if (size <= 0) {
+    return "Map{}";
+  }
+  options.truncate -= 7;
+  return `Map{ ${helpers.inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+module.exports = inspectMap;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/map.qwik.mjs

@@ -0,0 +1,26 @@
+import { inspectList } from "./helpers.qwik.mjs";
+function inspectMapEntry([key, value], options) {
+  options.truncate -= 4;
+  key = options.inspect(key, options);
+  options.truncate -= key.length;
+  value = options.inspect(value, options);
+  return `${key} => ${value}`;
+}
+function mapToEntries(map) {
+  const entries = [];
+  map.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+}
+function inspectMap(map, options) {
+  const size = map.size - 1;
+  if (size <= 0) {
+    return "Map{}";
+  }
+  options.truncate -= 7;
+  return `Map{ ${inspectList(mapToEntries(map), options, inspectMapEntry)} }`;
+}
+export {
+  inspectMap as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/number.qwik.cjs

@@ -0,0 +1,19 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+const isNaN = Number.isNaN || ((i) => i !== i);
+function inspectNumber(number, options) {
+  if (isNaN(number)) {
+    return options.stylize("NaN", "number");
+  }
+  if (number === Infinity) {
+    return options.stylize("Infinity", "number");
+  }
+  if (number === -Infinity) {
+    return options.stylize("-Infinity", "number");
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+  }
+  return options.stylize(helpers.truncate(String(number), options.truncate), "number");
+}
+module.exports = inspectNumber;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/number.qwik.mjs

@@ -0,0 +1,20 @@
+import { truncate } from "./helpers.qwik.mjs";
+const isNaN = Number.isNaN || ((i) => i !== i);
+function inspectNumber(number, options) {
+  if (isNaN(number)) {
+    return options.stylize("NaN", "number");
+  }
+  if (number === Infinity) {
+    return options.stylize("Infinity", "number");
+  }
+  if (number === -Infinity) {
+    return options.stylize("-Infinity", "number");
+  }
+  if (number === 0) {
+    return options.stylize(1 / number === Infinity ? "+0" : "-0", "number");
+  }
+  return options.stylize(truncate(String(number), options.truncate), "number");
+}
+export {
+  inspectNumber as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/object.qwik.cjs

@@ -0,0 +1,24 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+function inspectObject(object, options) {
+  const properties = Object.getOwnPropertyNames(object);
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  if (properties.length === 0 && symbols.length === 0) {
+    return "{}";
+  }
+  options.truncate -= 4;
+  options.seen = options.seen || [];
+  if (options.seen.indexOf(object) >= 0) {
+    return "[Circular]";
+  }
+  options.seen.push(object);
+  const propertyContents = helpers.inspectList(properties.map((key) => [key, object[key]]), options, helpers.inspectProperty);
+  const symbolContents = helpers.inspectList(symbols.map((key) => [key, object[key]]), options, helpers.inspectProperty);
+  options.seen.pop();
+  let sep = "";
+  if (propertyContents && symbolContents) {
+    sep = ", ";
+  }
+  return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+module.exports = inspectObject;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/object.qwik.mjs

@@ -0,0 +1,25 @@
+import { inspectList, inspectProperty } from "./helpers.qwik.mjs";
+function inspectObject(object, options) {
+  const properties = Object.getOwnPropertyNames(object);
+  const symbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(object) : [];
+  if (properties.length === 0 && symbols.length === 0) {
+    return "{}";
+  }
+  options.truncate -= 4;
+  options.seen = options.seen || [];
+  if (options.seen.indexOf(object) >= 0) {
+    return "[Circular]";
+  }
+  options.seen.push(object);
+  const propertyContents = inspectList(properties.map((key) => [key, object[key]]), options, inspectProperty);
+  const symbolContents = inspectList(symbols.map((key) => [key, object[key]]), options, inspectProperty);
+  options.seen.pop();
+  let sep = "";
+  if (propertyContents && symbolContents) {
+    sep = ", ";
+  }
+  return `{ ${propertyContents}${sep}${symbolContents} }`;
+}
+export {
+  inspectObject as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/promise.qwik.cjs

@@ -0,0 +1,17 @@
+"use strict";
+let getPromiseValue = () => "Promise{…}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
+const inspectPromise = getPromiseValue;
+module.exports = inspectPromise;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/promise.qwik.mjs

@@ -0,0 +1,18 @@
+let getPromiseValue = () => "Promise{…}";
+try {
+  const { getPromiseDetails, kPending, kRejected } = process.binding("util");
+  if (Array.isArray(getPromiseDetails(Promise.resolve()))) {
+    getPromiseValue = (value, options) => {
+      const [state, innerValue] = getPromiseDetails(value);
+      if (state === kPending) {
+        return "Promise{<pending>}";
+      }
+      return `Promise${state === kRejected ? "!" : ""}{${options.inspect(innerValue, options)}}`;
+    };
+  }
+} catch (notNode) {
+}
+const inspectPromise = getPromiseValue;
+export {
+  inspectPromise as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/regexp.qwik.cjs

@@ -0,0 +1,9 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+function inspectRegExp(value, options) {
+  const flags = value.toString().split("/")[2];
+  const sourceLength = options.truncate - (2 + flags.length);
+  const source = value.source;
+  return options.stylize(`/${helpers.truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+module.exports = inspectRegExp;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/regexp.qwik.mjs

@@ -0,0 +1,10 @@
+import { truncate } from "./helpers.qwik.mjs";
+function inspectRegExp(value, options) {
+  const flags = value.toString().split("/")[2];
+  const sourceLength = options.truncate - (2 + flags.length);
+  const source = value.source;
+  return options.stylize(`/${truncate(source, sourceLength)}/${flags}`, "regexp");
+}
+export {
+  inspectRegExp as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/set.qwik.cjs

@@ -0,0 +1,16 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+function arrayFromSet(set) {
+  const values = [];
+  set.forEach((value) => {
+    values.push(value);
+  });
+  return values;
+}
+function inspectSet(set, options) {
+  if (set.size === 0)
+    return "Set{}";
+  options.truncate -= 7;
+  return `Set{ ${helpers.inspectList(arrayFromSet(set), options)} }`;
+}
+module.exports = inspectSet;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/set.qwik.mjs

@@ -0,0 +1,17 @@
+import { inspectList } from "./helpers.qwik.mjs";
+function arrayFromSet(set) {
+  const values = [];
+  set.forEach((value) => {
+    values.push(value);
+  });
+  return values;
+}
+function inspectSet(set, options) {
+  if (set.size === 0)
+    return "Set{}";
+  options.truncate -= 7;
+  return `Set{ ${inspectList(arrayFromSet(set), options)} }`;
+}
+export {
+  inspectSet as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/string.qwik.cjs

@@ -0,0 +1,24 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+const stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+const escapeCharacters = {
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  "'": "\\'",
+  "\\": "\\\\"
+};
+const hex = 16;
+const unicodeLength = 4;
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
+}
+function inspectString(string, options) {
+  if (stringEscapeChars.test(string)) {
+    string = string.replace(stringEscapeChars, escape);
+  }
+  return options.stylize(`'${helpers.truncate(string, options.truncate - 2)}'`, "string");
+}
+module.exports = inspectString;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/string.qwik.mjs

@@ -0,0 +1,25 @@
+import { truncate } from "./helpers.qwik.mjs";
+const stringEscapeChars = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", "g");
+const escapeCharacters = {
+  "\b": "\\b",
+  "	": "\\t",
+  "\n": "\\n",
+  "\f": "\\f",
+  "\r": "\\r",
+  "'": "\\'",
+  "\\": "\\\\"
+};
+const hex = 16;
+const unicodeLength = 4;
+function escape(char) {
+  return escapeCharacters[char] || `\\u${`0000${char.charCodeAt(0).toString(hex)}`.slice(-unicodeLength)}`;
+}
+function inspectString(string, options) {
+  if (stringEscapeChars.test(string)) {
+    string = string.replace(stringEscapeChars, escape);
+  }
+  return options.stylize(`'${truncate(string, options.truncate - 2)}'`, "string");
+}
+export {
+  inspectString as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/symbol.qwik.cjs

@@ -0,0 +1,8 @@
+"use strict";
+function inspectSymbol(value) {
+  if ("description" in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : "Symbol()";
+  }
+  return value.toString();
+}
+module.exports = inspectSymbol;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/symbol.qwik.mjs

@@ -0,0 +1,9 @@
+function inspectSymbol(value) {
+  if ("description" in Symbol.prototype) {
+    return value.description ? `Symbol(${value.description})` : "Symbol()";
+  }
+  return value.toString();
+}
+export {
+  inspectSymbol as default
+};

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/typedarray.qwik.cjs

@@ -0,0 +1,34 @@
+"use strict";
+const helpers = require("./helpers.qwik.cjs");
+const getArrayName = (array) => {
+  if (typeof Buffer === "function" && array instanceof Buffer) {
+    return "Buffer";
+  }
+  if (array[Symbol.toStringTag]) {
+    return array[Symbol.toStringTag];
+  }
+  return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+  const name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return `${name}[]`;
+  let output = "";
+  for (let i = 0; i < array.length; i++) {
+    const string = `${options.stylize(helpers.truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+    options.truncate -= string.length;
+    if (array[i] !== array.length && options.truncate <= 3) {
+      output += `${helpers.truncator}(${array.length - array[i] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = helpers.inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, helpers.inspectProperty);
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+module.exports = inspectTypedArray;

package/lib/node_modules/.pnpm/loupe@3.1.1/node_modules/loupe/lib/typedarray.qwik.mjs

@@ -0,0 +1,35 @@
+import { truncate, truncator, inspectList, inspectProperty } from "./helpers.qwik.mjs";
+const getArrayName = (array) => {
+  if (typeof Buffer === "function" && array instanceof Buffer) {
+    return "Buffer";
+  }
+  if (array[Symbol.toStringTag]) {
+    return array[Symbol.toStringTag];
+  }
+  return array.constructor.name;
+};
+function inspectTypedArray(array, options) {
+  const name = getArrayName(array);
+  options.truncate -= name.length + 4;
+  const nonIndexProperties = Object.keys(array).slice(array.length);
+  if (!array.length && !nonIndexProperties.length)
+    return `${name}[]`;
+  let output = "";
+  for (let i = 0; i < array.length; i++) {
+    const string = `${options.stylize(truncate(array[i], options.truncate), "number")}${i === array.length - 1 ? "" : ", "}`;
+    options.truncate -= string.length;
+    if (array[i] !== array.length && options.truncate <= 3) {
+      output += `${truncator}(${array.length - array[i] + 1})`;
+      break;
+    }
+    output += string;
+  }
+  let propertyContents = "";
+  if (nonIndexProperties.length) {
+    propertyContents = inspectList(nonIndexProperties.map((key) => [key, array[key]]), options, inspectProperty);
+  }
+  return `${name}[ ${output}${propertyContents ? `, ${propertyContents}` : ""} ]`;
+}
+export {
+  inspectTypedArray as default
+};