docs: 仓库链接指向本镜像仓库

.pnpm-store/v11/files/5d/01ba2c91edbdf7c3c1d535c3f739393aab7cd87ebf9c2760f8de05fb0e3929501e2dafeacd8ad7d1444006694feaf2bc75a4fb98ed35723838787377ceb05d

@@ -0,0 +1,595 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABILITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+interface Array<T> {
+    /**
+     * Returns the value of the first element in the array where predicate is true, and undefined
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found, find
+     * immediately returns that element value. Otherwise, find returns undefined.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    find<S extends T>(predicate: (value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
+
+    /**
+     * Returns the index of the first element in the array where predicate is true, and -1
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found,
+     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+
+    /**
+     * Changes all array elements from `start` to `end` index to a static `value` and returns the modified array
+     * @param value value to fill array section with
+     * @param start index to start filling the array at. If start is negative, it is treated as
+     * length+start where length is the length of the array.
+     * @param end index to stop filling the array at. If end is negative, it is treated as
+     * length+end.
+     */
+    fill(value: T, start?: number, end?: number): this;
+
+    /**
+     * Returns the this object after copying a section of the array identified by start and end
+     * to the same array starting at position target
+     * @param target If target is negative, it is treated as length+target where length is the
+     * length of the array.
+     * @param start If start is negative, it is treated as length+start. If end is negative, it
+     * is treated as length+end.
+     * @param end If not specified, length of the this object is used as its default value.
+     */
+    copyWithin(target: number, start: number, end?: number): this;
+
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+}
+
+interface ArrayConstructor {
+    /**
+     * Creates an array from an array-like object.
+     * @param arrayLike An array-like object to convert to an array.
+     */
+    from<T>(arrayLike: ArrayLike<T>): T[];
+
+    /**
+     * Creates an array from an iterable object.
+     * @param arrayLike An array-like object to convert to an array.
+     * @param mapfn A mapping function to call on every element of the array.
+     * @param thisArg Value of 'this' used to invoke the mapfn.
+     */
+    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+
+    /**
+     * Returns a new array from a set of elements.
+     * @param items A set of elements to include in the new array object.
+     */
+    of<T>(...items: T[]): T[];
+}
+
+interface DateConstructor {
+    new (value: number | string | Date): Date;
+}
+
+interface Function {
+    /**
+     * Returns the name of the function. Function names are read-only and can not be changed.
+     */
+    readonly name: string;
+}
+
+interface Math {
+    /**
+     * Returns the number of leading zero bits in the 32-bit binary representation of a number.
+     * @param x A numeric expression.
+     */
+    clz32(x: number): number;
+
+    /**
+     * Returns the result of 32-bit multiplication of two numbers.
+     * @param x First number
+     * @param y Second number
+     */
+    imul(x: number, y: number): number;
+
+    /**
+     * Returns the sign of the x, indicating whether x is positive, negative or zero.
+     * @param x The numeric expression to test
+     */
+    sign(x: number): number;
+
+    /**
+     * Returns the base 10 logarithm of a number.
+     * @param x A numeric expression.
+     */
+    log10(x: number): number;
+
+    /**
+     * Returns the base 2 logarithm of a number.
+     * @param x A numeric expression.
+     */
+    log2(x: number): number;
+
+    /**
+     * Returns the natural logarithm of 1 + x.
+     * @param x A numeric expression.
+     */
+    log1p(x: number): number;
+
+    /**
+     * Returns the result of (e^x - 1), which is an implementation-dependent approximation to
+     * subtracting 1 from the exponential function of x (e raised to the power of x, where e
+     * is the base of the natural logarithms).
+     * @param x A numeric expression.
+     */
+    expm1(x: number): number;
+
+    /**
+     * Returns the hyperbolic cosine of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    cosh(x: number): number;
+
+    /**
+     * Returns the hyperbolic sine of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    sinh(x: number): number;
+
+    /**
+     * Returns the hyperbolic tangent of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    tanh(x: number): number;
+
+    /**
+     * Returns the inverse hyperbolic cosine of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    acosh(x: number): number;
+
+    /**
+     * Returns the inverse hyperbolic sine of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    asinh(x: number): number;
+
+    /**
+     * Returns the inverse hyperbolic tangent of a number.
+     * @param x A numeric expression that contains an angle measured in radians.
+     */
+    atanh(x: number): number;
+
+    /**
+     * Returns the square root of the sum of squares of its arguments.
+     * @param values Values to compute the square root for.
+     *     If no arguments are passed, the result is +0.
+     *     If there is only one argument, the result is the absolute value.
+     *     If any argument is +Infinity or -Infinity, the result is +Infinity.
+     *     If any argument is NaN, the result is NaN.
+     *     If all arguments are either +0 or −0, the result is +0.
+     */
+    hypot(...values: number[]): number;
+
+    /**
+     * Returns the integral part of the numeric expression x, removing any fractional digits.
+     * If x is already an integer, the result is x.
+     * @param x A numeric expression.
+     */
+    trunc(x: number): number;
+
+    /**
+     * Returns the nearest single precision float representation of a number.
+     * @param x A numeric expression.
+     */
+    fround(x: number): number;
+
+    /**
+     * Returns an implementation-dependent approximation to the cube root of number.
+     * @param x A numeric expression.
+     */
+    cbrt(x: number): number;
+}
+
+interface NumberConstructor {
+    /**
+     * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
+     * that is representable as a Number value, which is approximately:
+     * 2.2204460492503130808472633361816 x 10‍−‍16.
+     */
+    readonly EPSILON: number;
+
+    /**
+     * Returns true if passed value is finite.
+     * Unlike the global isFinite, Number.isFinite doesn't forcibly convert the parameter to a
+     * number. Only finite values of the type number, result in true.
+     * @param number A numeric value.
+     */
+    isFinite(number: unknown): boolean;
+
+    /**
+     * Returns true if the value passed is an integer, false otherwise.
+     * @param number A numeric value.
+     */
+    isInteger(number: unknown): boolean;
+
+    /**
+     * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
+     * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
+     * to a number. Only values of the type number, that are also NaN, result in true.
+     * @param number A numeric value.
+     */
+    isNaN(number: unknown): boolean;
+
+    /**
+     * Returns true if the value passed is a safe integer.
+     * @param number A numeric value.
+     */
+    isSafeInteger(number: unknown): boolean;
+
+    /**
+     * The value of the largest integer n such that n and n + 1 are both exactly representable as
+     * a Number value.
+     * The value of Number.MAX_SAFE_INTEGER is 9007199254740991 2^53 − 1.
+     */
+    readonly MAX_SAFE_INTEGER: number;
+
+    /**
+     * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+     * a Number value.
+     * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
+     */
+    readonly MIN_SAFE_INTEGER: number;
+
+    /**
+     * Converts a string to a floating-point number.
+     * @param string A string that contains a floating-point number.
+     */
+    parseFloat(string: string): number;
+
+    /**
+     * Converts A string to an integer.
+     * @param string A string to convert into a number.
+     * @param radix A value between 2 and 36 that specifies the base of the number in `string`.
+     * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
+     * All other strings are considered decimal.
+     */
+    parseInt(string: string, radix?: number): number;
+}
+
+interface ObjectConstructor {
+    /**
+     * Copy the values of all of the enumerable own properties from one or more source objects to a
+     * target object. Returns the target object.
+     * @param target The target object to copy to.
+     * @param source The source object from which to copy properties.
+     */
+    assign<T extends {}, U>(target: T, source: U): T & U;
+
+    /**
+     * Copy the values of all of the enumerable own properties from one or more source objects to a
+     * target object. Returns the target object.
+     * @param target The target object to copy to.
+     * @param source1 The first source object from which to copy properties.
+     * @param source2 The second source object from which to copy properties.
+     */
+    assign<T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+
+    /**
+     * Copy the values of all of the enumerable own properties from one or more source objects to a
+     * target object. Returns the target object.
+     * @param target The target object to copy to.
+     * @param source1 The first source object from which to copy properties.
+     * @param source2 The second source object from which to copy properties.
+     * @param source3 The third source object from which to copy properties.
+     */
+    assign<T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+
+    /**
+     * Copy the values of all of the enumerable own properties from one or more source objects to a
+     * target object. Returns the target object.
+     * @param target The target object to copy to.
+     * @param sources One or more source objects from which to copy properties
+     */
+    assign(target: object, ...sources: any[]): any;
+
+    /**
+     * Returns an array of all symbol properties found directly on object o.
+     * @param o Object to retrieve the symbols from.
+     */
+    getOwnPropertySymbols(o: any): symbol[];
+
+    /**
+     * Returns the names of the enumerable string properties and methods of an object.
+     * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+     */
+    keys(o: {}): string[];
+
+    /**
+     * Returns true if the values are the same value, false otherwise.
+     * @param value1 The first value.
+     * @param value2 The second value.
+     */
+    is(value1: any, value2: any): boolean;
+
+    /**
+     * Sets the prototype of a specified object o to object proto or null. Returns the object o.
+     * @param o The object to change its prototype.
+     * @param proto The value of the new prototype or null.
+     */
+    setPrototypeOf(o: any, proto: object | null): any;
+}
+
+interface ReadonlyArray<T> {
+    /**
+     * Returns the value of the first element in the array where predicate is true, and undefined
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found, find
+     * immediately returns that element value. Otherwise, find returns undefined.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    find<S extends T>(predicate: (value: T, index: number, obj: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): T | undefined;
+
+    /**
+     * Returns the index of the first element in the array where predicate is true, and -1
+     * otherwise.
+     * @param predicate find calls predicate once for each element of the array, in ascending
+     * order, until it finds one where predicate returns true. If such an element is found,
+     * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+     * @param thisArg If provided, it will be used as the this value for each invocation of
+     * predicate. If it is not provided, undefined is used instead.
+     */
+    findIndex(predicate: (value: T, index: number, obj: readonly T[]) => unknown, thisArg?: any): number;
+
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+}
+
+interface RegExp {
+    /**
+     * Returns a string indicating the flags of the regular expression in question. This field is read-only.
+     * The characters in this string are sequenced and concatenated in the following order:
+     *
+     *    - "g" for global
+     *    - "i" for ignoreCase
+     *    - "m" for multiline
+     *    - "u" for unicode
+     *    - "y" for sticky
+     *
+     * If no flags are set, the value is the empty string.
+     */
+    readonly flags: string;
+
+    /**
+     * Returns a Boolean value indicating the state of the sticky flag (y) used with a regular
+     * expression. Default is false. Read-only.
+     */
+    readonly sticky: boolean;
+
+    /**
+     * Returns a Boolean value indicating the state of the Unicode flag (u) used with a regular
+     * expression. Default is false. Read-only.
+     */
+    readonly unicode: boolean;
+}
+
+interface RegExpConstructor {
+    new (pattern: RegExp | string, flags?: string): RegExp;
+    (pattern: RegExp | string, flags?: string): RegExp;
+}
+
+interface String {
+    /**
+     * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+     * value of the UTF-16 encoded code point starting at the string element at position pos in
+     * the String resulting from converting this object to a String.
+     * If there is no element at that position, the result is undefined.
+     * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
+     */
+    codePointAt(pos: number): number | undefined;
+
+    /**
+     * Returns true if searchString appears as a substring of the result of converting this
+     * object to a String, at one or more positions that are
+     * greater than or equal to position; otherwise, returns false.
+     * @param searchString search string
+     * @param position If position is undefined, 0 is assumed, so as to search all of the String.
+     */
+    includes(searchString: string, position?: number): boolean;
+
+    /**
+     * Returns true if the sequence of elements of searchString converted to a String is the
+     * same as the corresponding elements of this object (converted to a String) starting at
+     * endPosition – length(this). Otherwise returns false.
+     */
+    endsWith(searchString: string, endPosition?: number): boolean;
+
+    /**
+     * Returns the String value result of normalizing the string into the normalization form
+     * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms.
+     * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default
+     * is "NFC"
+     */
+    normalize(form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+
+    /**
+     * Returns the String value result of normalizing the string into the normalization form
+     * named by form as specified in Unicode Standard Annex #15, Unicode Normalization Forms.
+     * @param form Applicable values: "NFC", "NFD", "NFKC", or "NFKD", If not specified default
+     * is "NFC"
+     */
+    normalize(form?: string): string;
+
+    /**
+     * Returns a String value that is made from count copies appended together. If count is 0,
+     * the empty string is returned.
+     * @param count number of copies to append
+     */
+    repeat(count: number): string;
+
+    /**
+     * Returns true if the sequence of elements of searchString converted to a String is the
+     * same as the corresponding elements of this object (converted to a String) starting at
+     * position. Otherwise returns false.
+     */
+    startsWith(searchString: string, position?: number): boolean;
+
+    /**
+     * Returns an `<a>` HTML anchor element and sets the name attribute to the text value
+     * @deprecated A legacy feature for browser compatibility
+     * @param name
+     */
+    anchor(name: string): string;
+
+    /**
+     * Returns a `<big>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    big(): string;
+
+    /**
+     * Returns a `<blink>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    blink(): string;
+
+    /**
+     * Returns a `<b>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    bold(): string;
+
+    /**
+     * Returns a `<tt>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    fixed(): string;
+
+    /**
+     * Returns a `<font>` HTML element and sets the color attribute value
+     * @deprecated A legacy feature for browser compatibility
+     */
+    fontcolor(color: string): string;
+
+    /**
+     * Returns a `<font>` HTML element and sets the size attribute value
+     * @deprecated A legacy feature for browser compatibility
+     */
+    fontsize(size: number): string;
+
+    /**
+     * Returns a `<font>` HTML element and sets the size attribute value
+     * @deprecated A legacy feature for browser compatibility
+     */
+    fontsize(size: string): string;
+
+    /**
+     * Returns an `<i>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    italics(): string;
+
+    /**
+     * Returns an `<a>` HTML element and sets the href attribute value
+     * @deprecated A legacy feature for browser compatibility
+     */
+    link(url: string): string;
+
+    /**
+     * Returns a `<small>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    small(): string;
+
+    /**
+     * Returns a `<strike>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    strike(): string;
+
+    /**
+     * Returns a `<sub>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    sub(): string;
+
+    /**
+     * Returns a `<sup>` HTML element
+     * @deprecated A legacy feature for browser compatibility
+     */
+    sup(): string;
+}
+
+interface StringConstructor {
+    /**
+     * Return the String value whose elements are, in order, the elements in the List elements.
+     * If length is 0, the empty string is returned.
+     */
+    fromCodePoint(...codePoints: number[]): string;
+
+    /**
+     * String.raw is usually used as a tag function of a Tagged Template String. When called as
+     * such, the first argument will be a well formed template call site object and the rest
+     * parameter will contain the substitution values. It can also be called directly, for example,
+     * to interleave strings and values from your own tag function, and in this case the only thing
+     * it needs from the first argument is the raw property.
+     * @param template A well-formed template string call site representation.
+     * @param substitutions A set of substitution values.
+     */
+    raw(template: { raw: readonly string[] | ArrayLike<string>; }, ...substitutions: any[]): string;
+}
+
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}
+
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
+}

.pnpm-store/v11/files/5d/03af3f6122da60219335275c7e581d15d069a7d5f0512ef0dcb348057ffb857b5c37e7d1a46baa920bdad264c0b0a4ef82b87c0db6f633c03aae9b6a45b9f7

@@ -0,0 +1,101 @@
+import { checkOptionalParameter } from "../../utils/url.js";
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
+import { createNullObject } from "../utils.js";
+import { emptyParam, match } from "./matcher.js";
+import { LABEL_REG_EXP_STR, PATH_ERROR, TAIL_WILDCARD_REG_EXP_STR } from "./node.js";
+import { Trie } from "./trie.js";
+//#region src/router/reg-exp-router/router.ts
+let wildcardRegExpCache = createNullObject();
+function buildWildcardRegExp(path) {
+	return wildcardRegExpCache[path] ??= new RegExp(`^${path.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match, metaChar) => metaChar ? `\\${metaChar}` : match === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
+}
+function findMiddleware(middleware, path) {
+	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path)) return [...middleware[k]];
+}
+var RegExpRouter = class {
+	name = "RegExpRouter";
+	#middleware;
+	#routes;
+	#tries;
+	constructor() {
+		this.#middleware = { ["ALL"]: createNullObject() };
+		this.#routes = { ["ALL"]: createNullObject() };
+		this.#tries = { ["ALL"]: new Trie() };
+	}
+	#insertPath(method, path) {
+		try {
+			this.#tries[method].insert(path, !/\*|\/:/.test(path));
+		} catch (e) {
+			throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+		}
+	}
+	add(method, path, handler) {
+		const middleware = this.#middleware;
+		const routes = this.#routes;
+		if (!middleware) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+		if (!middleware[method]) {
+			this.#tries[method] = new Trie();
+			for (const handlerMap of [middleware, routes]) {
+				handlerMap[method] = createNullObject();
+				for (const p in handlerMap["ALL"]) {
+					handlerMap[method][p] = [...handlerMap["ALL"][p]];
+					this.#insertPath(method, p);
+				}
+			}
+		}
+		if (path === "/*") path = "*";
+		const methods = method === "ALL" ? Object.keys(middleware) : [method];
+		if (/\*$/.test(path)) {
+			const re = buildWildcardRegExp(path);
+			for (const m of methods) if (!middleware[m][path]) {
+				this.#insertPath(m, path);
+				middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			for (const handlerMap of [middleware, routes]) for (const m of methods) for (const p in handlerMap[m]) re.test(p) && handlerMap[m][p].push([handler, path]);
+			return;
+		}
+		const paths = checkOptionalParameter(path) || [path];
+		for (const path of paths) for (const m of methods) {
+			if (!routes[m][path]) {
+				this.#insertPath(m, path);
+				routes[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+			}
+			routes[m][path].push([handler, path]);
+		}
+	}
+	match = match;
+	buildAllMatchers() {
+		const matchers = createNullObject();
+		for (const method of Object.keys(this.#routes)) matchers[method] = this.#buildMatcher(method);
+		this.#middleware = this.#routes = this.#tries = void 0;
+		wildcardRegExpCache = createNullObject();
+		return matchers;
+	}
+	#buildMatcher(method) {
+		const middleware = this.#middleware[method];
+		const routes = this.#routes[method];
+		const trie = this.#tries[method];
+		const staticMap = createNullObject();
+		const handlerData = [];
+		const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+		for (const r of [middleware, routes]) for (const path in r) {
+			const handlers = r[path];
+			const pathData = trie.paths[path];
+			if (!pathData) {
+				staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+				continue;
+			}
+			handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [h, trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+				map[key] = paramReplacementMap[pathData[1][i][1]];
+				return map;
+			}, createNullObject())]);
+		}
+		return [
+			regexp,
+			indexReplacementMap.map((i) => handlerData[i]),
+			staticMap
+		];
+	}
+};
+//#endregion
+export { RegExpRouter };

.pnpm-store/v11/files/5d/061188ce42d3fe08584ff48b50d9aabd9b646b3c24732849327a27a80802d0f414dce57bda7c31966c3ac00cf483cd9ab5f9d7f4f35c39d844ebff26624336

@@ -0,0 +1 @@
+{"version":3,"file":"chart-bar-decreasing.js","sources":["../../../src/icons/chart-bar-decreasing.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name ChartBarDecreasing\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMyAzdjE2YTIgMiAwIDAgMCAyIDJoMTYiIC8+CiAgPHBhdGggZD0iTTcgMTFoOCIgLz4KICA8cGF0aCBkPSJNNyAxNmgzIiAvPgogIDxwYXRoIGQ9Ik03IDZoMTIiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/chart-bar-decreasing\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst ChartBarDecreasing = createLucideIcon('ChartBarDecreasing', [\n  ['path', { d: 'M3 3v16a2 2 0 0 0 2 2h16', key: 'c24i48' }],\n  ['path', { d: 'M7 11h8', key: '1feolt' }],\n  ['path', { d: 'M7 16h3', key: 'ur6vzw' }],\n  ['path', { d: 'M7 6h12', key: 'sz5b0d' }],\n]);\n\nexport default ChartBarDecreasing;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAqB,iBAAiB,oBAAsB,CAAA,CAAA,CAAA;AAAA,CAAA,CAChE,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA4B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACzD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACxC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACxC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC1C,CAAC,CAAA,CAAA;;"}

.pnpm-store/v11/files/5d/063ce1de1877a9e51df7a6ab53e17ecf0eeac2c11cbe87cf91e5b0e58cc670551c67ac721181b82205f6bee0afdea2ad099518549b64e29e42e98bb7c4c0dd

@@ -0,0 +1,233 @@
+'use strict';
+
+Object.defineProperty(exports, 'commentRegex', {
+  get: function getCommentRegex () {
+    // Groups: 1: media type, 2: MIME type, 3: charset, 4: encoding, 5: data.
+    return /^\s*?\/[\/\*][@#]\s+?sourceMappingURL=data:(((?:application|text)\/json)(?:;charset=([^;,]+?)?)?)?(?:;(base64))?,(.*?)$/mg;
+  }
+});
+
+
+Object.defineProperty(exports, 'mapFileCommentRegex', {
+  get: function getMapFileCommentRegex () {
+    // Matches sourceMappingURL in either // or /* comment styles.
+    return /(?:\/\/[@#][ \t]+?sourceMappingURL=([^\s'"`]+?)[ \t]*?$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*?(?:\*\/){1}[ \t]*?$)/mg;
+  }
+});
+
+var decodeBase64;
+if (typeof Buffer !== 'undefined') {
+  if (typeof Buffer.from === 'function') {
+    decodeBase64 = decodeBase64WithBufferFrom;
+  } else {
+    decodeBase64 = decodeBase64WithNewBuffer;
+  }
+} else {
+  decodeBase64 = decodeBase64WithAtob;
+}
+
+function decodeBase64WithBufferFrom(base64) {
+  return Buffer.from(base64, 'base64').toString();
+}
+
+function decodeBase64WithNewBuffer(base64) {
+  if (typeof value === 'number') {
+    throw new TypeError('The value to decode must not be of type number.');
+  }
+  return new Buffer(base64, 'base64').toString();
+}
+
+function decodeBase64WithAtob(base64) {
+  return decodeURIComponent(escape(atob(base64)));
+}
+
+function stripComment(sm) {
+  return sm.split(',').pop();
+}
+
+function readFromFileMap(sm, read) {
+  var r = exports.mapFileCommentRegex.exec(sm);
+  // for some odd reason //# .. captures in 1 and /* .. */ in 2
+  var filename = r[1] || r[2];
+
+  try {
+    var sm = read(filename);
+    if (sm != null && typeof sm.catch === 'function') {
+      return sm.catch(throwError);
+    } else {
+      return sm;
+    }
+  } catch (e) {
+    throwError(e);
+  }
+
+  function throwError(e) {
+    throw new Error('An error occurred while trying to read the map file at ' + filename + '\n' + e.stack);
+  }
+}
+
+function Converter (sm, opts) {
+  opts = opts || {};
+
+  if (opts.hasComment) {
+    sm = stripComment(sm);
+  }
+
+  if (opts.encoding === 'base64') {
+    sm = decodeBase64(sm);
+  } else if (opts.encoding === 'uri') {
+    sm = decodeURIComponent(sm);
+  }
+
+  if (opts.isJSON || opts.encoding) {
+    sm = JSON.parse(sm);
+  }
+
+  this.sourcemap = sm;
+}
+
+Converter.prototype.toJSON = function (space) {
+  return JSON.stringify(this.sourcemap, null, space);
+};
+
+if (typeof Buffer !== 'undefined') {
+  if (typeof Buffer.from === 'function') {
+    Converter.prototype.toBase64 = encodeBase64WithBufferFrom;
+  } else {
+    Converter.prototype.toBase64 = encodeBase64WithNewBuffer;
+  }
+} else {
+  Converter.prototype.toBase64 = encodeBase64WithBtoa;
+}
+
+function encodeBase64WithBufferFrom() {
+  var json = this.toJSON();
+  return Buffer.from(json, 'utf8').toString('base64');
+}
+
+function encodeBase64WithNewBuffer() {
+  var json = this.toJSON();
+  if (typeof json === 'number') {
+    throw new TypeError('The json to encode must not be of type number.');
+  }
+  return new Buffer(json, 'utf8').toString('base64');
+}
+
+function encodeBase64WithBtoa() {
+  var json = this.toJSON();
+  return btoa(unescape(encodeURIComponent(json)));
+}
+
+Converter.prototype.toURI = function () {
+  var json = this.toJSON();
+  return encodeURIComponent(json);
+};
+
+Converter.prototype.toComment = function (options) {
+  var encoding, content, data;
+  if (options != null && options.encoding === 'uri') {
+    encoding = '';
+    content = this.toURI();
+  } else {
+    encoding = ';base64';
+    content = this.toBase64();
+  }
+  data = 'sourceMappingURL=data:application/json;charset=utf-8' + encoding + ',' + content;
+  return options != null && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+};
+
+// returns copy instead of original
+Converter.prototype.toObject = function () {
+  return JSON.parse(this.toJSON());
+};
+
+Converter.prototype.addProperty = function (key, value) {
+  if (this.sourcemap.hasOwnProperty(key)) throw new Error('property "' + key + '" already exists on the sourcemap, use set property instead');
+  return this.setProperty(key, value);
+};
+
+Converter.prototype.setProperty = function (key, value) {
+  this.sourcemap[key] = value;
+  return this;
+};
+
+Converter.prototype.getProperty = function (key) {
+  return this.sourcemap[key];
+};
+
+exports.fromObject = function (obj) {
+  return new Converter(obj);
+};
+
+exports.fromJSON = function (json) {
+  return new Converter(json, { isJSON: true });
+};
+
+exports.fromURI = function (uri) {
+  return new Converter(uri, { encoding: 'uri' });
+};
+
+exports.fromBase64 = function (base64) {
+  return new Converter(base64, { encoding: 'base64' });
+};
+
+exports.fromComment = function (comment) {
+  var m, encoding;
+  comment = comment
+    .replace(/^\/\*/g, '//')
+    .replace(/\*\/$/g, '');
+  m = exports.commentRegex.exec(comment);
+  encoding = m && m[4] || 'uri';
+  return new Converter(comment, { encoding: encoding, hasComment: true });
+};
+
+function makeConverter(sm) {
+  return new Converter(sm, { isJSON: true });
+}
+
+exports.fromMapFileComment = function (comment, read) {
+  if (typeof read === 'string') {
+    throw new Error(
+      'String directory paths are no longer supported with `fromMapFileComment`\n' +
+      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+    )
+  }
+
+  var sm = readFromFileMap(comment, read);
+  if (sm != null && typeof sm.then === 'function') {
+    return sm.then(makeConverter);
+  } else {
+    return makeConverter(sm);
+  }
+};
+
+// Finds last sourcemap comment in file or returns null if none was found
+exports.fromSource = function (content) {
+  var m = content.match(exports.commentRegex);
+  return m ? exports.fromComment(m.pop()) : null;
+};
+
+// Finds last sourcemap comment in file or returns null if none was found
+exports.fromMapFileSource = function (content, read) {
+  if (typeof read === 'string') {
+    throw new Error(
+      'String directory paths are no longer supported with `fromMapFileSource`\n' +
+      'Please review the Upgrading documentation at https://github.com/thlorenz/convert-source-map#upgrading'
+    )
+  }
+  var m = content.match(exports.mapFileCommentRegex);
+  return m ? exports.fromMapFileComment(m.pop(), read) : null;
+};
+
+exports.removeComments = function (src) {
+  return src.replace(exports.commentRegex, '');
+};
+
+exports.removeMapFileComments = function (src) {
+  return src.replace(exports.mapFileCommentRegex, '');
+};
+
+exports.generateMapFileComment = function (file, options) {
+  var data = 'sourceMappingURL=' + file;
+  return options && options.multiline ? '/*# ' + data + ' */' : '//# ' + data;
+};

.pnpm-store/v11/files/5d/0c68041ce05df2d888bccda92e45df41b766b5934ed6d4f211feb4af7fbf091922f74ecf166c853f1465666465b7065d7b2f226fcd6ee555a816d0681ac98f

@@ -0,0 +1,27 @@
+const checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
+const isCSSVariableName = 
+/*@__PURE__*/ checkStringStartsWith("--");
+const startsAsVariableToken = 
+/*@__PURE__*/ checkStringStartsWith("var(--");
+const isCSSVariableToken = (value) => {
+    const startsWithToken = startsAsVariableToken(value);
+    if (!startsWithToken)
+        return false;
+    // Ensure any comments are stripped from the value as this can harm performance of the regex.
+    return singleCssVariableRegex.test(value.split("/*")[0].trim());
+};
+const singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+/**
+ * Check if a value contains a CSS variable anywhere (e.g. inside calc()).
+ * Unlike isCSSVariableToken which checks if the value IS a var() token,
+ * this checks if the value CONTAINS var() somewhere in the string.
+ */
+function containsCSSVariable(value) {
+    if (typeof value !== "string")
+        return false;
+    // Strip comments to avoid false positives
+    return value.split("/*")[0].includes("var(--");
+}
+
+export { containsCSSVariable, isCSSVariableName, isCSSVariableToken };
+//# sourceMappingURL=is-css-variable.mjs.map

.pnpm-store/v11/files/5d/0ce254bd15c1e72553e87bc5a3c51fda76bb877c9d4ff94ab4af7b82a9eff557dfd015d3104c7c80c257e92743d63258be71812cc59708fd637976855cbe0d

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/use-previous.tsx"],
+  "sourcesContent": ["import * as React from 'react';\n\nfunction usePrevious<T>(value: T) {\n  const ref = React.useRef({ value, previous: value });\n\n  // We compare values before making an update to ensure that\n  // a change has been made. This ensures the previous value is\n  // persisted correctly between renders.\n  return React.useMemo(() => {\n    if (ref.current.value !== value) {\n      ref.current.previous = ref.current.value;\n      ref.current.value = value;\n    }\n    return ref.current.previous;\n  }, [value]);\n}\n\nexport { usePrevious };\n"],
+  "mappings": ";AAAA,YAAY,WAAW;AAEvB,SAAS,YAAe,OAAU;AAChC,QAAM,MAAY,aAAO,EAAE,OAAO,UAAU,MAAM,CAAC;AAKnD,SAAa,cAAQ,MAAM;AACzB,QAAI,IAAI,QAAQ,UAAU,OAAO;AAC/B,UAAI,QAAQ,WAAW,IAAI,QAAQ;AACnC,UAAI,QAAQ,QAAQ;AAAA,IACtB;AACA,WAAO,IAAI,QAAQ;AAAA,EACrB,GAAG,CAAC,KAAK,CAAC;AACZ;",
+  "names": []
+}

.pnpm-store/v11/files/5d/13c3f5768ef63913a56a33cde02b830ff3d0cc70a9f128e05802b0e557b01ec26357251396a61530c47c40da03204d32b21cc2b53c47cb2c0e6007a5e6801a

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-misused-new',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce valid definition of `new` and `constructor`',
+            recommended: 'recommended',
+        },
+        messages: {
+            errorMessageClass: 'Class cannot have method named `new`.',
+            errorMessageInterface: 'Interfaces cannot be constructed, only classes.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * @param node type to be inspected.
+         * @returns name of simple type or null
+         */
+        function getTypeReferenceName(node) {
+            if (node) {
+                switch (node.type) {
+                    case utils_1.AST_NODE_TYPES.TSTypeAnnotation:
+                        return getTypeReferenceName(node.typeAnnotation);
+                    case utils_1.AST_NODE_TYPES.TSTypeReference:
+                        return getTypeReferenceName(node.typeName);
+                    case utils_1.AST_NODE_TYPES.Identifier:
+                        return node.name;
+                    default:
+                        break;
+                }
+            }
+            return null;
+        }
+        /**
+         * @param parent parent node.
+         * @param returnType type to be compared
+         */
+        function isMatchingParentType(parent, returnType) {
+            if (parent &&
+                (parent.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                    parent.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+                    parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) &&
+                parent.id) {
+                return getTypeReferenceName(returnType) === parent.id.name;
+            }
+            return false;
+        }
+        return {
+            "ClassBody > MethodDefinition[key.name='new']"(node) {
+                if (node.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression &&
+                    isMatchingParentType(node.parent.parent, node.value.returnType)) {
+                    context.report({
+                        node,
+                        messageId: 'errorMessageClass',
+                    });
+                }
+            },
+            'TSInterfaceBody > TSConstructSignatureDeclaration'(node) {
+                if (isMatchingParentType(node.parent.parent, node.returnType)) {
+                    // constructor
+                    context.report({
+                        node,
+                        messageId: 'errorMessageInterface',
+                    });
+                }
+            },
+            "TSMethodSignature[key.name='constructor']"(node) {
+                context.report({
+                    node,
+                    messageId: 'errorMessageInterface',
+                });
+            },
+        };
+    },
+});

.pnpm-store/v11/files/5d/1431ff638f73c6b2bbe593fe0767c7296bcf92d7914980701921c2c309c75012c1771b0b26ded2804dd6a56f6bb5be8512e71a3fdbdfad37e1b9074570a509

@@ -0,0 +1,8 @@
+import type { CodeKeywordDefinition, ErrorObject } from "../../types";
+export type EnumError = ErrorObject<"enum", {
+    allowedValues: any[];
+}, any[] | {
+    $data: string;
+}>;
+declare const def: CodeKeywordDefinition;
+export default def;

.pnpm-store/v11/files/5d/166550cc0f09af6073a2bf6c4c53728b534b2635036eacd89b9ad615c447df59ff6f120c42865a7944bd8c0edc9827a69dd4cb95f1087d71f90eaa94118f0c

@@ -0,0 +1,94 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+const MALFORMED_HOST_ERROR = 'URI host is malformed.'
+
+const domainHostSchemes = ['http', 'https', 'ws', 'wss']
+
+// Hosts containing ASCII characters that RFC 3986 does not allow in a
+// reg-name. Handing them to the WHATWG URL parser would read "@" as a userinfo
+// delimiter (dropping the data before it) and strip TAB, LF and CR.
+const forbiddenHosts = [
+  'b@evil.example',
+  'ev\til.example',
+  'ev\nil.example',
+  'ev\ril.example',
+  'ev\r\nil.example',
+  'a b.example',
+  'a"b.example',
+  'a<b.example',
+  'a>b.example',
+  'a^b.example',
+  'a`b.example',
+  'a{b.example',
+  'a|b.example',
+  'a}b.example',
+  'a\u007Fb.example',
+  'a\u0000b.example'
+]
+
+test('domain hosts with forbidden ASCII characters fail closed', (t) => {
+  for (const scheme of domainHostSchemes) {
+    for (const host of forbiddenHosts) {
+      const uri = `${scheme}://user@${host}/path`
+      const label = JSON.stringify(uri)
+
+      const parsed = fastURI.parse(uri)
+      t.equal(parsed.error, MALFORMED_HOST_ERROR, `${label} reports a malformed host`)
+      t.notEqual(parsed.host, 'evil.example', `${label} does not report a truncated host`)
+
+      t.equal(fastURI.normalize(uri), uri, `${label} normalizes to itself`)
+      t.equal(fastURI.normalize(uri, { unicodeSupport: true }), uri, `${label} normalizes to itself with unicodeSupport`)
+      t.equal(fastURI.equal(uri, uri), false, `${label} is not comparable`)
+      t.equal(fastURI.equal(uri, `${scheme}://user@evil.example/path`), false, `${label} does not alias the stripped host`)
+
+      t.throws(
+        () => fastURI.resolve(`${scheme}://trusted.example/`, `//user@${host}/path`),
+        /URI host is malformed\./,
+        `${label} is rejected by resolve`
+      )
+    }
+  }
+  t.end()
+})
+
+test('a second "@" cannot move the authority to a different host', (t) => {
+  const uri = 'http://a@b@evil.example/'
+  const parsed = fastURI.parse(uri)
+  t.equal(parsed.userinfo, 'a')
+  t.notEqual(parsed.host, 'evil.example', 'host is not silently truncated')
+  t.equal(parsed.error, MALFORMED_HOST_ERROR)
+  t.equal(fastURI.normalize(uri), uri)
+
+  t.throws(
+    () => fastURI.resolve('http://trusted.example/', '//a@b%41@evil.example/p'),
+    /URI host is malformed\./,
+    'percent-encoded data does not bypass the check in resolve'
+  )
+  t.end()
+})
+
+test('the domainHost option applies the same rules to other schemes', (t) => {
+  const parsed = fastURI.parse('foo://a@b@evil.example/', { domainHost: true })
+  t.equal(parsed.error, MALFORMED_HOST_ERROR)
+  t.end()
+})
+
+test('valid domain hosts are unaffected', (t) => {
+  t.equal(fastURI.normalize('http://Example.COM/'), 'http://example.com/')
+  t.equal(fastURI.normalize('http://%65xample.com/'), 'http://example.com/')
+  t.equal(fastURI.normalize('http://bücher.de/'), 'http://xn--bcher-kva.de/')
+  t.equal(fastURI.normalize('http://bücher.de/', { unicodeSupport: true }), 'http://bücher.de/')
+  t.equal(fastURI.parse("http://a!$&'()*+,;=b.example/").error, undefined, 'sub-delims are allowed')
+  t.equal(fastURI.parse('http://user:pass@example.com:8080/').host, 'example.com')
+  t.equal(fastURI.resolve('http://trusted.example/', '//user@example.com/p'), 'http://user@example.com/p')
+  t.end()
+})
+
+test('schemes without domain hosts keep encoding reg-name data', (t) => {
+  t.equal(fastURI.normalize('foo://a@b@evil.example/'), 'foo://a@b%40evil.example/')
+  t.equal(fastURI.resolve('foo://x/', '//a@b@evil.example/p'), 'foo://a@b%40evil.example/p')
+  t.end()
+})

.pnpm-store/v11/files/5d/18c5170a57c8f93e069f79e22d4b5a1d50ef9b0e9b66d41893d30d67581718765b83f8ae2d0068433e84d318ca52153ed8e7a1ed9cbb399bb4e21aa50f9ed6

@@ -0,0 +1 @@
+{"version":3,"file":"Matches.cjs","names":[],"sources":["../../src/Matches.tsx"],"sourcesContent":["'use client'\n\nimport * as React from 'react'\nimport { useStore } from '@tanstack/react-store'\nimport { replaceEqualDeep, rootRouteId } from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { CatchBoundary, ErrorComponent } from './CatchBoundary'\nimport { useRouter } from './useRouter'\nimport { Transitioner } from './Transitioner'\nimport { matchContext } from './matchContext'\nimport { Match } from './Match'\nimport { SafeFragment } from './SafeFragment'\nimport type {\n  StructuralSharingOption,\n  ValidateSelected,\n} from './structuralSharing'\nimport type {\n  AnyRoute,\n  AnyRouter,\n  DeepPartial,\n  Expand,\n  MakeOptionalPathParams,\n  MakeOptionalSearchParams,\n  MakeRouteMatchUnion,\n  MaskOptions,\n  MatchRouteOptions,\n  RegisteredRouter,\n  ResolveRoute,\n  ToSubOptionsProps,\n} from '@tanstack/router-core'\n\ndeclare module '@tanstack/router-core' {\n  export interface RouteMatchExtensions {\n    meta?: Array<React.JSX.IntrinsicElements['meta'] | undefined>\n    links?: Array<React.JSX.IntrinsicElements['link'] | undefined>\n    scripts?: Array<React.JSX.IntrinsicElements['script'] | undefined>\n    styles?: Array<React.JSX.IntrinsicElements['style'] | undefined>\n    headScripts?: Array<React.JSX.IntrinsicElements['script'] | undefined>\n  }\n}\n\n/**\n * Internal component that renders the router's active match tree with\n * suspense, error, and not-found boundaries. Rendered by `RouterProvider`.\n */\nexport function Matches() {\n  const router = useRouter()\n  const rootRoute: AnyRoute = router.routesById[rootRouteId]\n\n  const PendingComponent =\n    rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent\n\n  const pendingElement = PendingComponent ? <PendingComponent /> : null\n\n  // Do not render a root Suspense during SSR or hydrating from SSR\n  const ResolvedSuspense =\n    (isServer ?? router.isServer) ||\n    (typeof document !== 'undefined' && router.ssr)\n      ? SafeFragment\n      : React.Suspense\n\n  const inner = (\n    <ResolvedSuspense fallback={pendingElement}>\n      {!(isServer ?? router.isServer) && <Transitioner />}\n      <MatchesInner />\n    </ResolvedSuspense>\n  )\n\n  return router.options.InnerWrap ? (\n    <router.options.InnerWrap>{inner}</router.options.InnerWrap>\n  ) : (\n    inner\n  )\n}\n\nfunction MatchesInner() {\n  const router = useRouter()\n  const _isServer = isServer ?? router.isServer\n  const matchId = _isServer\n    ? router.stores.firstId.get()\n    : // eslint-disable-next-line react-hooks/rules-of-hooks\n      useStore(router.stores.firstId, (id) => id)\n  const resetKey = _isServer\n    ? router.stores.loadedAt.get()\n    : // eslint-disable-next-line react-hooks/rules-of-hooks\n      useStore(router.stores.loadedAt, (loadedAt) => loadedAt)\n\n  const matchComponent = matchId ? <Match matchId={matchId} /> : null\n\n  return (\n    <matchContext.Provider value={matchId}>\n      {router.options.disableGlobalCatchBoundary ? (\n        matchComponent\n      ) : (\n        <CatchBoundary\n          getResetKey={() => resetKey}\n          errorComponent={ErrorComponent}\n          onCatch={\n            process.env.NODE_ENV !== 'production'\n              ? (error) => {\n                  console.warn(\n                    `Warning: The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!`,\n                  )\n                  console.warn(`Warning: ${error.message || error.toString()}`)\n                }\n              : undefined\n          }\n        >\n          {matchComponent}\n        </CatchBoundary>\n      )}\n    </matchContext.Provider>\n  )\n}\n\nexport type UseMatchRouteOptions<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TFrom extends string = string,\n  TTo extends string | undefined = undefined,\n  TMaskFrom extends string = TFrom,\n  TMaskTo extends string = '',\n> = ToSubOptionsProps<TRouter, TFrom, TTo> &\n  DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> &\n  DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> &\n  MaskOptions<TRouter, TMaskFrom, TMaskTo> &\n  MatchRouteOptions\n\n/**\n * Create a matcher function for testing locations against route definitions.\n *\n * The returned function accepts standard navigation options (`to`, `params`,\n * `search`, etc.) and returns either `false` (no match) or the matched params\n * object when the route matches the current or pending location.\n *\n * Useful for conditional rendering and active UI states.\n *\n * @returns A `matchRoute(options)` function that returns `false` or params.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchRouteHook\n */\nexport function useMatchRoute<TRouter extends AnyRouter = RegisteredRouter>() {\n  const router = useRouter()\n\n  if (!(isServer ?? routLine truncated

.pnpm-store/v11/files/5d/1dcabe9f00776290d9cbcc470fc3ec31a7885acefabb079a32bbe5843323147176319477623ec72c479565e8b74386d9bbf39564c412b87e0713fd44dda36a

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["src/get-innermost-scope.mjs","src/find-variable.mjs","src/token-predicate.mjs","src/get-function-head-location.mjs","src/get-static-value.mjs","src/get-string-if-constant.mjs","src/get-property-name.mjs","src/get-function-name-with-kind.mjs","src/has-side-effect.mjs","src/is-parenthesized.mjs","src/pattern-matcher.mjs","src/reference-tracker.mjs","src/index.mjs"],"sourcesContent":["/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"estree\").Node} Node */\n\n/**\n * Get the innermost scope which contains a given location.\n * @param {Scope} initialScope The initial scope to search.\n * @param {Node} node The location to search.\n * @returns {Scope} The innermost scope.\n */\nexport function getInnermostScope(initialScope, node) {\n    const location = /** @type {[number, number]} */ (node.range)[0]\n\n    let scope = initialScope\n    let found = false\n    do {\n        found = false\n        for (const childScope of scope.childScopes) {\n            const range = /** @type {[number, number]} */ (\n                childScope.block.range\n            )\n\n            if (range[0] <= location && location < range[1]) {\n                scope = childScope\n                found = true\n                break\n            }\n        }\n    } while (found)\n\n    return scope\n}\n","import { getInnermostScope } from \"./get-innermost-scope.mjs\"\n/** @typedef {import(\"eslint\").Scope.Scope} Scope */\n/** @typedef {import(\"eslint\").Scope.Variable} Variable */\n/** @typedef {import(\"estree\").Identifier} Identifier */\n\n/**\n * Find the variable of a given name.\n * @param {Scope} initialScope The scope to start finding.\n * @param {string|Identifier} nameOrNode The variable name to find. If this is a Node object then it should be an Identifier node.\n * @returns {Variable|null} The found variable or null.\n */\nexport function findVariable(initialScope, nameOrNode) {\n    let name = \"\"\n    /** @type {Scope|null} */\n    let scope = initialScope\n\n    if (typeof nameOrNode === \"string\") {\n        name = nameOrNode\n    } else {\n        name = nameOrNode.name\n        scope = getInnermostScope(scope, nameOrNode)\n    }\n\n    while (scope != null) {\n        const variable = scope.set.get(name)\n        if (variable != null) {\n            return variable\n        }\n        scope = scope.upper\n    }\n\n    return null\n}\n","/** @typedef {import(\"eslint\").AST.Token} Token */\n/** @typedef {import(\"estree\").Comment} Comment */\n/** @typedef {import(\"./types.mjs\").ArrowToken} ArrowToken */\n/** @typedef {import(\"./types.mjs\").CommaToken} CommaToken */\n/** @typedef {import(\"./types.mjs\").SemicolonToken} SemicolonToken */\n/** @typedef {import(\"./types.mjs\").ColonToken} ColonToken */\n/** @typedef {import(\"./types.mjs\").OpeningParenToken} OpeningParenToken */\n/** @typedef {import(\"./types.mjs\").ClosingParenToken} ClosingParenToken */\n/** @typedef {import(\"./types.mjs\").OpeningBracketToken} OpeningBracketToken */\n/** @typedef {import(\"./types.mjs\").ClosingBracketToken} ClosingBracketToken */\n/** @typedef {import(\"./types.mjs\").OpeningBraceToken} OpeningBraceToken */\n/** @typedef {import(\"./types.mjs\").ClosingBraceToken} ClosingBraceToken */\n/**\n * @template {string} Value\n * @typedef {import(\"./types.mjs\").PunctuatorToken<Value>} PunctuatorToken\n */\n\n/** @typedef {Comment | Token} CommentOrToken */\n\n/**\n * Creates the negate function of the given function.\n * @param {function(CommentOrToken):boolean} f - The function to negate.\n * @returns {function(CommentOrToken):boolean} Negated function.\n */\nfunction negate(f) {\n    return (token) => !f(token)\n}\n\n/**\n * Checks if the given token is a PunctuatorToken with the given value\n * @template {string} Value\n * @param {CommentOrToken} token - The token to check.\n * @param {Value} value - The value to check.\n * @returns {token is PunctuatorToken<Value>} `true` if the token is a PunctuatorToken with the given value.\n */\nfunction isPunctuatorTokenWithValue(token, value) {\n    return token.type === \"Punctuator\" && token.value === value\n}\n\n/**\n * Checks if the given token is an arrow token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is ArrowToken} `true` if the token is an arrow token.\n */\nexport function isArrowToken(token) {\n    return isPunctuatorTokenWithValue(token, \"=>\")\n}\n\n/**\n * Checks if the given token is a comma token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is CommaToken} `true` if the token is a comma token.\n */\nexport function isCommaToken(token) {\n    return isPunctuatorTokenWithValue(token, \",\")\n}\n\n/**\n * Checks if the given token is a semicolon token or not.\n * @param {CommentOrToken} token - The token to check.\n * @returns {token is SemicolonToken} `true` if the token is a semicolon token.\n */\nexport function isSeLine truncated

.pnpm-store/v11/files/5d/204df34a7eb69f384aeb90f0e3e99c930cf77f338ac9ae4b9b344940a95fc778e18f49f59f6a932caff4b8f126f2f34e0c1aa24d0558af68d50537308cd7bb

@@ -0,0 +1,26 @@
+import { expect, test } from "vitest";
+import { type infer as _infer, json, nullable, object, pipe, transform } from "../../mini/index.js";
+// biome-ignore lint/correctness/noUnusedImports: This import verifies the type is exported
+import type { _ZodMiniJSONSchema } from "../../mini/schemas.js";
+
+const DataType = object({
+  data: json(),
+});
+type DataType = _infer<typeof DataType>;
+
+// biome-ignore lint/suspicious/noExportsInTest: This export is required to reproduce TS4023
+export const Container = object({
+  contained: pipe(
+    nullable(DataType),
+    transform<DataType | null>(
+      (v) =>
+        v ?? {
+          data: "",
+        }
+    )
+  ),
+});
+
+test("issue reproduction should compile without type errors", () => {
+  expect(Container).toBeDefined();
+});

.pnpm-store/v11/files/5d/2488d864b2130fd50c88d48a3c6b851e994f218b873afecd7f36453fb85c79eb1b115f49e24ec081787e59e4424208d413eb97411573251c09b77812516019

@@ -0,0 +1,22 @@
+'use strict';
+
+const defaultExtension = require('./default-extension.js');
+const testFileExtensions = defaultExtension
+	.map(extension => extension.slice(1))
+	.join(',');
+
+module.exports = [
+	'coverage/**',
+	'packages/*/test{,s}/**',
+	'**/*.d.ts',
+	'test{,s}/**',
+	`test{,-*}.{${testFileExtensions}}`,
+	`**/*{.,-}test.{${testFileExtensions}}`,
+	'**/__tests__/**',
+
+	/* Exclude common development tool configuration files */
+	'**/{ava,babel,nyc}.config.{js,cjs,mjs}',
+	'**/jest.config.{js,cjs,mjs,ts}',
+	'**/{karma,rollup,webpack}.config.js',
+	'**/.{eslint,mocha}rc.{js,cjs}'
+];

.pnpm-store/v11/files/5d/2761085cc4c13291b24e6089023d47127f17cb548d4593475b39ce2e627f642c2c0e0eb4d48bfc8e396b8233c132ab8c9a4366c35fe3ff4db3f88a4e607376

@@ -0,0 +1,623 @@
+export default `flf2a$ 6 5 20 0 9 0
+
+ticks.flf (C) 1994 by Victor Parada (vparada@inf.utfsm.cl) 94/09/23.
+
+figlet 2.1 font based on slide.flf.
+
+Try option "-m 1" to smush one "_" between fonts.
+
+Latin fonts a' e' i' o' u' n~ and N~ replaces A" O" U" a" o" u" and B.
+
+____@
+____@
+____@
+____@
+____@
+____@@
+_/\\/\\_@
+_/\\/\\_@
+_/\\/\\_@
+______@
+_/\\/\\_@
+______@@
+_/\\/\\/\\/\\_@
+_/\\/\\/\\/\\_@
+_/\\__/\\___@
+__________@
+__________@
+__________@@
+___/\\/\\__/\\/\\___@
+_/\\/\\/\\/\\/\\/\\/\\_@
+___/\\/\\__/\\/\\___@
+_/\\/\\/\\/\\/\\/\\/\\_@
+___/\\/\\__/\\/\\___@
+________________@@
+_____/\\/\\_____@
+___/\\/\\/\\/\\/\\_@
+_/\\/\\/\\/\\_____@
+_____/\\/\\/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+_____/\\/\\_____@@
+_/\\/\\____/\\/\\_@
+_/\\/\\__/\\/\\___@
+_____/\\/\\_____@
+___/\\/\\__/\\/\\_@
+_/\\/\\____/\\/\\_@
+______________@@
+_____/\\/\\_______@
+_____/\\/\\_______@
+___/\\/\\/\\__/\\/\\_@
+_/\\/\\____/\\/\\___@
+___/\\/\\/\\__/\\/\\_@
+________________@@
+_/\\/\\_@
+_/\\/\\_@
+_/\\___@
+______@
+______@
+______@@
+___/\\/\\/\\_@
+_/\\/\\/\\___@
+_/\\/\\_____@
+_/\\/\\/\\___@
+___/\\/\\/\\_@
+__________@@
+_/\\/\\/\\___@
+___/\\/\\/\\_@
+_____/\\/\\_@
+___/\\/\\/\\_@
+_/\\/\\/\\___@
+__________@@
+___/\\/\\__/\\/\\___@
+_____/\\/\\/\\_____@
+_/\\/\\/\\/\\/\\/\\/\\_@
+_____/\\/\\/\\_____@
+___/\\/\\__/\\/\\___@
+________________@@
+______________@
+_____/\\/\\_____@
+_/\\/\\/\\/\\/\\/\\_@
+_____/\\/\\_____@
+______________@
+______________@@
+______@
+______@
+______@
+_/\\/\\_@
+_/\\/\\_@
+_/\\___@@
+__________@
+__________@
+_/\\/\\/\\/\\_@
+__________@
+__________@
+__________@@
+______@
+______@
+______@
+_/\\/\\_@
+_/\\/\\_@
+______@@
+_________/\\/\\_@
+_______/\\/\\___@
+_____/\\/\\_____@
+___/\\/\\_______@
+_/\\/\\_________@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+___/\\/\\_@
+_/\\/\\/\\_@
+___/\\/\\_@
+___/\\/\\_@
+___/\\/\\_@
+________@@
+_/\\/\\/\\/\\/\\___@
+_________/\\/\\_@
+___/\\/\\/\\/\\___@
+_/\\/\\_________@
+_/\\/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\/\\/\\/\\___@
+_________/\\/\\_@
+___/\\/\\/\\/\\___@
+_________/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+______________@@
+_____/\\/\\/\\___@
+___/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\___@
+_/\\/\\/\\/\\/\\/\\_@
+_______/\\/\\___@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\_________@
+_/\\/\\/\\/\\/\\___@
+_________/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\_________@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_______/\\/\\___@
+_____/\\/\\_____@
+___/\\/\\_______@
+_/\\/\\_________@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\/\\_@
+_________/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+_/\\/\\_@
+_/\\/\\_@
+______@
+_/\\/\\_@
+_/\\/\\_@
+______@@
+_/\\/\\_@
+_/\\/\\_@
+______@
+_/\\/\\_@
+_/\\/\\_@
+_/\\___@@
+_____/\\/\\_@
+___/\\/\\___@
+_/\\/\\_____@
+___/\\/\\___@
+_____/\\/\\_@
+__________@@
+__________@
+_/\\/\\/\\/\\_@
+__________@
+_/\\/\\/\\/\\_@
+__________@
+__________@@
+_/\\/\\_____@
+___/\\/\\___@
+_____/\\/\\_@
+___/\\/\\___@
+_/\\/\\_____@
+__________@@
+_/\\/\\/\\/\\/\\___@
+_________/\\/\\_@
+_____/\\/\\/\\___@
+______________@
+_____/\\/\\_____@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\_________@
+___/\\/\\/\\/\\___@
+______________@@
+_____/\\/\\_____@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\____/\\/\\_@
+______________@@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+______________@@
+___/\\/\\/\\/\\/\\_@
+_/\\/\\_________@
+_/\\/\\_________@
+_/\\/\\_________@
+___/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\___________@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\_________@
+_/\\/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\_________@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\_________@
+_/\\/\\_________@
+______________@@
+___/\\/\\/\\/\\/\\_@
+_/\\/\\_________@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+______________@@
+_/\\/\\/\\/\\_@
+___/\\/\\___@
+___/\\/\\___@
+___/\\/\\___@
+_/\\/\\/\\/\\_@
+__________@@
+_________/\\/\\_@
+_________/\\/\\_@
+_________/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\__/\\/\\___@
+_/\\/\\/\\/\\_____@
+_/\\/\\__/\\/\\___@
+_/\\/\\____/\\/\\_@
+______________@@
+_/\\/\\_______@
+_/\\/\\_______@
+_/\\/\\_______@
+_/\\/\\_______@
+_/\\/\\/\\/\\/\\_@
+____________@@
+_/\\/\\______/\\/\\_@
+_/\\/\\/\\__/\\/\\/\\_@
+_/\\/\\/\\/\\/\\/\\/\\_@
+_/\\/\\__/\\__/\\/\\_@
+_/\\/\\______/\\/\\_@
+________________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\____/\\/\\_@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\_________@
+_/\\/\\_________@
+______________@@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\__/\\/\\___@
+___/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\___@
+_/\\/\\____/\\/\\_@
+______________@@
+___/\\/\\/\\/\\/\\_@
+_/\\/\\_________@
+___/\\/\\/\\/\\___@
+_________/\\/\\_@
+_/\\/\\/\\/\\/\\___@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_____/\\/\\_____@
+_____/\\/\\_____@
+_____/\\/\\_____@
+_____/\\/\\_____@
+______________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+______________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+_____/\\/\\_____@
+______________@@
+_/\\/\\______/\\/\\_@
+_/\\/\\__/\\__/\\/\\_@
+_/\\/\\/\\/\\/\\/\\/\\_@
+_/\\/\\/\\__/\\/\\/\\_@
+_/\\/\\______/\\/\\_@
+________________@@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+_____/\\/\\_____@
+___/\\/\\/\\/\\___@
+_/\\/\\____/\\/\\_@
+______________@@
+_/\\/\\____/\\/\\_@
+_/\\/\\____/\\/\\_@
+___/\\/\\/\\/\\___@
+_____/\\/\\_____@
+_____/\\/\\_____@
+______________@@
+_/\\/\\/\\/\\/\\/\\_@
+_______/\\/\\___@
+_____/\\/\\_____@
+___/\\/\\_______@
+_/\\/\\/\\/\\/\\/\\_@
+______________@@
+_/\\/\\/\\/\\_@
+_/\\/\\_____@
+_/\\/\\_____@
+_/\\/\\_____@
+_/\\/\\/\\/\\_@
+__________@@
+_/\\/\\_________@
+___/\\/\\_______@
+_____/\\/\\_____@
+_______/\\/\\___@
+_________/\\/\\_@
+______________@@
+_/\\/\\/\\/\\_@
+_____/\\/\\_@
+_____/\\/\\_@
+_____/\\/\\_@
+_/\\/\\/\\/\\_@
+__________@@
+___/\\/\\___@
+_/\\/\\/\\/\\_@
+_/\\____/\\_@
+__________@
+__________@
+__________@@
+______________@
+______________@
+______________@
+______________@
+______________@
+_/\\/\\/\\/\\/\\/\\_@@
+_/\\/\\_@
+_/\\/\\_@
+___/\\_@
+______@
+______@
+______@@
+____________@
+_/\\/\\/\\_____@
+_____/\\/\\___@
+_/\\/\\/\\/\\___@
+_/\\/\\/\\/\\/\\_@
+____________@@
+_/\\/\\_______@
+_/\\/\\_______@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\___@
+____________@@
+____________@
+___/\\/\\/\\/\\_@
+_/\\/\\_______@
+_/\\/\\_______@
+___/\\/\\/\\/\\_@
+____________@@
+_______/\\/\\_@
+_______/\\/\\_@
+___/\\/\\/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+____________@@
+____________@
+___/\\/\\/\\___@
+_/\\/\\/\\/\\/\\_@
+_/\\/\\_______@
+___/\\/\\/\\/\\_@
+____________@@
+___/\\/\\/\\_@
+_/\\/\\_____@
+_/\\/\\/\\___@
+_/\\/\\_____@
+_/\\/\\_____@
+__________@@
+____________@
+___/\\/\\/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+_______/\\/\\_@
+_/\\/\\/\\/\\___@@
+_/\\/\\_______@
+_/\\/\\_______@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+____________@@
+_/\\/\\___@
+________@
+_/\\/\\___@
+_/\\/\\___@
+_/\\/\\/\\_@
+________@@
+_____/\\/\\_@
+__________@
+_____/\\/\\_@
+_____/\\/\\_@
+_____/\\/\\_@
+_/\\/\\/\\___@@
+_/\\/\\_______@
+_/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\___@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+____________@@
+_/\\/\\___@
+_/\\/\\___@
+_/\\/\\___@
+_/\\/\\___@
+_/\\/\\/\\_@
+________@@
+________________@
+_/\\/\\/\\__/\\/\\___@
+_/\\/\\/\\/\\/\\/\\/\\_@
+_/\\/\\__/\\__/\\/\\_@
+_/\\/\\______/\\/\\_@
+________________@@
+____________@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+____________@@
+____________@
+___/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\___@
+____________@@
+____________@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\___@
+_/\\/\\_______@
+_/\\/\\_______@@
+____________@
+___/\\/\\/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+_______/\\/\\_@
+_______/\\/\\_@@
+____________@
+_/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\___@
+_/\\/\\_______@
+_/\\/\\_______@
+____________@@
+____________@
+___/\\/\\/\\/\\_@
+_/\\/\\/\\/\\___@
+_______/\\/\\_@
+_/\\/\\/\\/\\___@
+____________@@
+___/\\/\\_____@
+_/\\/\\/\\/\\/\\_@
+___/\\/\\_____@
+___/\\/\\_____@
+___/\\/\\/\\___@
+____________@@
+____________@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+____________@@
+____________@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\___@
+_____/\\_____@
+____________@@
+________________@
+_/\\/\\______/\\/\\_@
+_/\\/\\__/\\__/\\/\\_@
+_/\\/\\/\\/\\/\\/\\/\\_@
+___/\\/\\__/\\/\\___@
+________________@@
+____________@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\___@
+___/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+____________@@
+____________@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+_______/\\/\\_@
+_/\\/\\/\\/\\___@@
+____________@
+_/\\/\\/\\/\\/\\_@
+_____/\\/\\___@
+___/\\/\\_____@
+_/\\/\\/\\/\\/\\_@
+____________@@
+___/\\/\\/\\/\\_@
+___/\\/\\_____@
+_/\\/\\_______@
+___/\\/\\_____@
+___/\\/\\/\\/\\_@
+____________@@
+_/\\/\\_@
+_/\\/\\_@
+_/\\/\\_@
+_/\\/\\_@
+_/\\/\\_@
+_/\\/\\_@@
+_/\\/\\/\\/\\___@
+_____/\\/\\___@
+_______/\\/\\_@
+_____/\\/\\___@
+_/\\/\\/\\/\\___@
+____________@@
+___/\\/\\__/\\/\\_@
+_/\\/\\/\\/\\/\\/\\_@
+_/\\/\\__/\\/\\___@
+______________@
+______________@
+______________@@
+_______/\\/\\_@
+_/\\/\\/\\_____@
+_____/\\/\\___@
+_/\\/\\/\\/\\___@
+_/\\/\\/\\/\\/\\_@
+____________@@
+_______/\\/\\_@
+___/\\/\\/\\___@
+_/\\/\\/\\/\\/\\_@
+_/\\/\\_______@
+___/\\/\\/\\/\\_@
+____________@@
+___/\\/\\_@
+________@
+_/\\/\\___@
+_/\\/\\___@
+_/\\/\\/\\_@
+________@@
+_______/\\/\\_@
+___/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\___@
+____________@@
+_______/\\/\\_@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+___/\\/\\/\\/\\_@
+____________@@
+_/\\/\\/\\/\\/\\_@
+____________@
+_/\\/\\/\\/\\___@
+_/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\_@
+____________@@
+_/\\/\\/\\/\\/\\/\\_@
+______________@
+_/\\/\\/\\__/\\/\\_@
+_/\\/\\__/\\/\\/\\_@
+_/\\/\\____/\\/\\_@
+______________@@
+`

.pnpm-store/v11/files/5d/2fa6d24004d76738b697736e8486c9da4d0764079b4eb64d532e2c983f18148f041681e2d3a0df2c95465be3f7458c9fc2031b1259808072da2530d00c4cc6

@@ -0,0 +1,252 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParseSettings = createParseSettings;
+exports.clearTSConfigMatchCache = clearTSConfigMatchCache;
+exports.clearTSServerProjectService = clearTSServerProjectService;
+const project_service_1 = require("@typescript-eslint/project-service");
+const debug_1 = __importDefault(require("debug"));
+const node_path_1 = __importDefault(require("node:path"));
+const ts = __importStar(require("typescript"));
+const shared_1 = require("../create-program/shared");
+const validateDefaultProjectForFilesGlob_1 = require("../create-program/validateDefaultProjectForFilesGlob");
+const source_files_1 = require("../source-files");
+const candidateTSConfigRootDirs_1 = require("./candidateTSConfigRootDirs");
+const ExpiringCache_1 = require("./ExpiringCache");
+const getProjectConfigFiles_1 = require("./getProjectConfigFiles");
+const inferSingleRun_1 = require("./inferSingleRun");
+const resolveProjectList_1 = require("./resolveProjectList");
+const warnAboutTSVersion_1 = require("./warnAboutTSVersion");
+const log = (0, debug_1.default)('typescript-eslint:typescript-estree:parseSettings:createParseSettings');
+let TSCONFIG_MATCH_CACHE;
+let TSSERVER_PROJECT_SERVICE = null;
+// NOTE - we intentionally use "unnecessary" `?.` here because in TS<5.3 this enum doesn't exist
+// This object exists so we can centralize these for tracking and so we don't proliferate these across the file
+// https://github.com/microsoft/TypeScript/issues/56579
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+const JSDocParsingMode = {
+    ParseAll: ts.JSDocParsingMode?.ParseAll,
+    ParseForTypeErrors: ts.JSDocParsingMode?.ParseForTypeErrors,
+    ParseForTypeInfo: ts.JSDocParsingMode?.ParseForTypeInfo,
+    ParseNone: ts.JSDocParsingMode?.ParseNone,
+};
+/* eslint-enable @typescript-eslint/no-unnecessary-condition */
+function createParseSettings(code, tsestreeOptions = {}) {
+    const codeFullText = enforceCodeString(code);
+    const singleRun = (0, inferSingleRun_1.inferSingleRun)(tsestreeOptions);
+    const tsconfigRootDir = (() => {
+        if (tsestreeOptions.tsconfigRootDir == null) {
+            const inferredTsconfigRootDir = (0, candidateTSConfigRootDirs_1.getInferredTSConfigRootDir)();
+            if (node_path_1.default.resolve(inferredTsconfigRootDir) !== inferredTsconfigRootDir) {
+                throw new Error(`inferred tsconfigRootDir should be a resolved absolute path, but received: ${JSON.stringify(inferredTsconfigRootDir)}. This is a bug in typescript-eslint! Please report it to us at https://github.com/typescript-eslint/typescript-eslint/issues/new/choose.`);
+            }
+            return inferredTsconfigRootDir;
+        }
+        if (typeof tsestreeOptions.tsconfigRootDir === 'string') {
+            const userProvidedTsconfigRootDir = tsestreeOptions.tsconfigRootDir;
+            if (!node_path_1.default.isAbsolute(userProvidedTsconfigRootDir) ||
+                // Ensure it's fully absolute with a drive letter if windows
+                (process.platform === 'win32' &&
+                    !/^[a-zA-Z]:/.test(userProvidedTsconfigRootDir))) {
+                throw new Error(`parserOptions.tsconfigRootDir must be an absolute path, but received: ${JSON.stringify(userProvidedTsconfigRootDir)}. This is a bug in your configuration; please supply an absolute path.`);
+            }
+            // Deal with any funny business around trailing path separators (a/b/) or relative path segments (/a/b/../c)
+            // Since we already know it's absolute, we can safely use path.resolve here.
+            return node_path_1.default.resolve(userProvidedTsconfigRootDir);
+        }
+        throw new Error(`If provided, parserOptions.tsconfigRootDir must be a string, but received a value of type "${typeof tsestreeOptions.tsconfigRootDir}"`);
+    })();
+    const passedLoggerFn = typeof tsestreeOptions.loggerFn === 'function';
+    const filePath = (0, shared_1.ensureAbsolutePath)(typeof tsestreeOptions.filePath === 'string' &&
+        tsestreeOptions.filePath !== '<input>'
+        ? tsestreeOptions.filePath
+        : getFileName(tsestreeOptions.jsx), tsconfigRootDir);
+    const extension = node_path_1.default.extname(filePath).toLowerCase();
+    const jsDocParsingMode = (() => {
+        switch (tsestreeOptions.jsDocParsingMode) {
+            case 'all':
+                return JSDocParsingMode.ParseAll;
+            case 'none':
+                return JSDocParsingMode.ParseNone;
+            case 'type-info':
+                return JSDocParsingMode.ParseForTypeInfo;
+            default:
+                return JSDocParsingMode.ParseAll;
+        }
+    })();
+    const parseSettings = {
+        loc: tsestreeOptions.loc === true,
+        range: tsestreeOptions.range === true,
+        allowInvalidAST: tsestreeOptions.allowInvalidAST === true,
+        code,
+        codeFullText,
+        comment: tsestreeOptions.comment === true,
+        comments: [],
+        debugLevel: tsestreeOptions.debugLevel === true
+            ? new Set(['typescript-eslint'])
+            : Array.isArray(tsestreeOptions.debugLevel)
+                ? new Set(tsestreeOptions.debugLevel)
+                : new Set(),
+        errorOnTypeScriptSyntacticAndSemanticIssues: false,
+        errorOnUnknownASTType: tsestreeOptions.errorOnUnknownASTType === true,
+        extraFileExtensions: Array.isArray(tsestreeOptions.extraFileExtensions) &&
+            tsestreeOptions.extraFileExtensions.every(ext => typeof ext === 'string')
+            ? tsestreeOptions.extraFileExtensions
+            : [],
+        filePath,
+        jsDocParsingMode,
+        jsx: tsestreeOptions.jsx === true,
+        log: typeof tsestreeOptions.loggerFn === 'function'
+            ? tsestreeOptions.loggerFn
+            : tsestreeOptions.loggerFn === false
+                ? () => { } // eslint-disable-line @typescript-eslint/no-empty-function
+                : console.log, // eslint-disable-line no-console
+        preserveNodeMaps: tsestreeOptions.preserveNodeMaps !== false,
+        programs: Array.isArray(tsestreeOptions.programs)
+            ? tsestreeOptions.programs
+            : null,
+        projects: new Map(),
+        projectService: tsestreeOptions.projectService ||
+            (tsestreeOptions.project &&
+                tsestreeOptions.projectService !== false &&
+                process.env.TYPESCRIPT_ESLINT_PROJECT_SERVICE === 'true')
+            ? populateProjectService(tsestreeOptions.projectService, {
+                jsDocParsingMode,
+                tsconfigRootDir,
+            })
+            : undefined,
+        setExternalModuleIndicator: tsestreeOptions.sourceType === 'module' ||
+            (tsestreeOptions.sourceType == null && extension === ts.Extension.Mjs) ||
+            (tsestreeOptions.sourceType == null && extension === ts.Extension.Mts)
+            ? (file) => {
+                file.externalModuleIndicator = true;
+            }
+            : undefined,
+        singleRun,
+        suppressDeprecatedPropertyWarnings: tsestreeOptions.suppressDeprecatedPropertyWarnings ??
+            process.env.NODE_ENV !== 'test',
+        tokens: tsestreeOptions.tokens === true ? [] : null,
+        tsconfigMatchCache: (TSCONFIG_MATCH_CACHE ??= new ExpiringCache_1.ExpiringCache(singleRun
+            ? 'Infinity'
+            : (tsestreeOptions.cacheLifetime?.glob ??
+                ExpiringCache_1.DEFAULT_TSCONFIG_CACHE_DURATION_SECONDS))),
+        tsconfigRootDir,
+    };
+    // TODO: Eventually, parse settings will be validated more thoroughly.
+    // https://github.com/typescript-eslint/typescript-eslint/issues/6403
+    if (parseSettings.projectService &&
+        tsestreeOptions.project &&
+        process.env.TYPESCRIPT_ESLINT_IGNORE_PROJECT_AND_PROJECT_SERVICE_ERROR !==
+            'true') {
+        throw new Error('Enabling "project" does nothing when "projectService" is enabled. You can remove the "project" setting.');
+    }
+    // debug doesn't support multiple `enable` calls, so have to do it all at once
+    if (parseSettings.debugLevel.size > 0) {
+        const namespaces = [];
+        if (parseSettings.debugLevel.has('typescript-eslint')) {
+            namespaces.push('typescript-eslint:*');
+        }
+        if (parseSettings.debugLevel.has('eslint') ||
+            // make sure we don't turn off the eslint debug if it was enabled via --debug
+            debug_1.default.enabled('eslint:*,-eslint:code-path')) {
+            // https://github.com/eslint/eslint/blob/9dfc8501fb1956c90dc11e6377b4cb38a6bea65d/bin/eslint.js#L25
+            namespaces.push('eslint:*,-eslint:code-path');
+        }
+        debug_1.default.enable(namespaces.join(','));
+    }
+    if (Array.isArray(tsestreeOptions.programs)) {
+        if (!tsestreeOptions.programs.length) {
+            throw new Error(`You have set parserOptions.programs to an empty array. This will cause all files to not be found in existing programs. Either provide one or more existing TypeScript Program instances in the array, or remove the parserOptions.programs setting.`);
+        }
+        log('parserOptions.programs was provided, so parserOptions.project will be ignored.');
+    }
+    // Providing a program or project service overrides project resolution
+    if (!parseSettings.programs && !parseSettings.projectService) {
+        parseSettings.projects = (0, resolveProjectList_1.resolveProjectList)({
+            cacheLifetime: tsestreeOptions.cacheLifetime,
+            project: (0, getProjectConfigFiles_1.getProjectConfigFiles)(parseSettings, tsestreeOptions.project),
+            projectFolderIgnoreList: tsestreeOptions.projectFolderIgnoreList,
+            singleRun: parseSettings.singleRun,
+            tsconfigRootDir,
+        });
+    }
+    // No type-aware linting which means that cross-file (or even same-file) JSDoc is useless
+    // So in this specific case we default to 'none' if no value was provided
+    if (tsestreeOptions.jsDocParsingMode == null &&
+        parseSettings.projects.size === 0 &&
+        parseSettings.programs == null &&
+        parseSettings.projectService == null) {
+        parseSettings.jsDocParsingMode = JSDocParsingMode.ParseNone;
+    }
+    (0, warnAboutTSVersion_1.warnAboutTSVersion)(parseSettings, passedLoggerFn);
+    return parseSettings;
+}
+function clearTSConfigMatchCache() {
+    TSCONFIG_MATCH_CACHE?.clear();
+}
+function clearTSServerProjectService() {
+    TSSERVER_PROJECT_SERVICE = null;
+}
+/**
+ * Ensures source code is a string.
+ */
+function enforceCodeString(code) {
+    return (0, source_files_1.isSourceFile)(code)
+        ? code.getFullText(code)
+        : typeof code === 'string'
+            ? code
+            : String(code);
+}
+/**
+ * Compute the filename based on the parser options.
+ *
+ * Even if jsx option is set in typescript compiler, filename still has to
+ * contain .tsx file extension.
+ */
+function getFileName(jsx) {
+    return jsx ? 'estree.tsx' : 'estree.ts';
+}
+function populateProjectService(optionsRaw, settings) {
+    const options = typeof optionsRaw === 'object' ? optionsRaw : {};
+    (0, validateDefaultProjectForFilesGlob_1.validateDefaultProjectForFilesGlob)(options.allowDefaultProject);
+    TSSERVER_PROJECT_SERVICE ??= (0, project_service_1.createProjectService)({
+        options,
+        ...settings,
+    });
+    return TSSERVER_PROJECT_SERVICE;
+}

.pnpm-store/v11/files/5d/3d6419c341fbf1bf315aedcd34891ab70ae5832d6326da35c8bb44cb22837af92b23b2024b6e2c6944052bfbc64b42b3eebc0664727f583f4c1cf1c9153332

@@ -0,0 +1,512 @@
+'use strict';
+
+var formats = require('./formats');
+var getSideChannel = require('side-channel');
+var defineProperty = require('es-define-property');
+
+var has = Object.prototype.hasOwnProperty;
+var isArray = Array.isArray;
+
+// Track objects created from arrayLimit overflow using side-channel
+// Stores the current max numeric index for O(1) lookup
+var overflowChannel = getSideChannel();
+
+var markOverflow = function markOverflow(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+    return obj;
+};
+
+var isOverflow = function isOverflow(obj) {
+    return overflowChannel.has(obj);
+};
+
+var getMaxIndex = function getMaxIndex(obj) {
+    return overflowChannel.get(obj);
+};
+
+var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+};
+
+// Track containers produced by a `strictMerge` conflict wrap, and their current max numeric index,
+// so repeated conflicts on one path append instead of nesting a new wrapper each time
+var conflictChannel = getSideChannel();
+
+var markConflict = function markConflict(obj, maxIndex) {
+    conflictChannel.set(obj, maxIndex);
+    return obj;
+};
+
+var isConflict = function isConflict(obj) {
+    return conflictChannel.has(obj);
+};
+
+var getConflictIndex = function getConflictIndex(obj) {
+    return conflictChannel.get(obj);
+};
+
+var hexTable = (function () {
+    var array = [];
+    for (var i = 0; i < 256; ++i) {
+        array[array.length] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
+    }
+
+    return array;
+}());
+
+var compactQueue = function compactQueue(queue) {
+    while (queue.length > 1) {
+        var item = queue.pop();
+        var obj = item.obj[item.prop];
+
+        if (isArray(obj)) {
+            var compacted = [];
+
+            for (var j = 0; j < obj.length; ++j) {
+                if (typeof obj[j] !== 'undefined') {
+                    compacted[compacted.length] = obj[j];
+                }
+            }
+
+            item.obj[item.prop] = compacted;
+        }
+    }
+};
+
+var arrayToObject = function arrayToObject(source, options) {
+    var obj = options && options.plainObjects ? { __proto__: null } : {};
+    for (var i = 0; i < source.length; ++i) {
+        if (typeof source[i] !== 'undefined') {
+            obj[i] = source[i];
+        }
+    }
+
+    return obj;
+};
+
+var setProperty = function setProperty(obj, key, value) {
+    if (key === '__proto__' && defineProperty) {
+        defineProperty(obj, key, {
+            configurable: true,
+            enumerable: true,
+            value: value,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+};
+
+var maxNumericIndex = function maxNumericIndex(obj, min) {
+    var max = min;
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; ++i) {
+        var num = parseInt(keys[i], 10);
+        if (String(num) === keys[i] && num > max) {
+            max = num;
+        }
+    }
+
+    return max;
+};
+
+var limitedPair = function limitedPair(first, second, options) {
+    var pair = [first, second];
+    if (options && typeof options.arrayLimit === 'number' && pair.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+            throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+        }
+        return markOverflow(arrayToObject(pair, options), 1);
+    }
+    return pair;
+};
+
+var merge = function merge(target, source, options) {
+    /* eslint no-param-reassign: 0 */
+    if (!source) {
+        return target;
+    }
+
+    if (typeof source !== 'object' && typeof source !== 'function') {
+        if (isArray(target)) {
+            var nextIndex = target.length;
+            if (options && typeof options.arrayLimit === 'number' && nextIndex >= options.arrayLimit) {
+                if (options.throwOnLimitExceeded) {
+                    throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+                }
+                return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+            }
+            target[nextIndex] = source;
+        } else if (target && typeof target === 'object') {
+            if (isOverflow(target)) {
+                // Add at next numeric index for overflow objects
+                var newIndex = getMaxIndex(target) + 1;
+                target[newIndex] = source;
+                setMaxIndex(target, newIndex);
+            } else if (options && options.strictMerge && isConflict(target)) {
+                var nextConflict = getConflictIndex(target) + 1;
+                if (
+                    options.throwOnLimitExceeded
+                    && typeof options.arrayLimit === 'number'
+                    && nextConflict >= options.arrayLimit
+                ) {
+                    throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+                }
+                target[nextConflict] = source;
+                markConflict(target, nextConflict);
+            } else if (options && options.strictMerge) {
+                var conflict = limitedPair(target, source, options);
+                return isArray(conflict) ? markConflict(conflict, 1) : conflict;
+            } else if (
+                (options && (options.plainObjects || options.allowPrototypes))
+                || !has.call(Object.prototype, source)
+            ) {
+                target[source] = true;
+            }
+        } else {
+            return limitedPair(target, source, options);
+        }
+
+        return target;
+    }
+
+    if (!target || typeof target !== 'object') {
+        if (isOverflow(source)) {
+            // Create new object with target at 0, source values shifted by 1
+            var sourceKeys = Object.keys(source);
+            var result = options && options.plainObjects
+                ? { __proto__: null, 0: target }
+                : { 0: target };
+            for (var m = 0; m < sourceKeys.length; m++) {
+                var oldKey = parseInt(sourceKeys[m], 10);
+                result[oldKey + 1] = source[sourceKeys[m]];
+            }
+            return markOverflow(result, getMaxIndex(source) + 1);
+        }
+        var combined = [target].concat(source);
+        if (options && typeof options.arrayLimit === 'number' && combined.length > options.arrayLimit) {
+            if (options.throwOnLimitExceeded) {
+                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+            }
+            return markOverflow(arrayToObject(combined, options), combined.length - 1);
+        }
+        return combined;
+    }
+
+    var mergeTarget = target;
+    if (isArray(target) && !isArray(source)) {
+        mergeTarget = arrayToObject(target, options);
+        if (isConflict(target)) {
+            // the array may have grown past its last conflict, so continue after its last index
+            markConflict(mergeTarget, target.length - 1);
+        }
+    }
+
+    if (isArray(target) && isArray(source)) {
+        source.forEach(function (item, i) {
+            if (has.call(target, i)) {
+                var targetItem = target[i];
+                if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+                    target[i] = merge(targetItem, item, options);
+                } else {
+                    target[target.length] = item;
+                }
+            } else {
+                target[i] = item;
+            }
+        });
+        if (options && typeof options.arrayLimit === 'number' && target.length > options.arrayLimit) {
+            if (options.throwOnLimitExceeded) {
+                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+            }
+            return markOverflow(arrayToObject(target, options), target.length - 1);
+        }
+        return target;
+    }
+
+    return Object.keys(source).reduce(function (acc, key) {
+        var value = source[key];
+
+        if (has.call(acc, key)) {
+            setProperty(acc, key, merge(acc[key], value, options));
+        } else {
+            setProperty(acc, key, value);
+        }
+
+        if (isOverflow(source) && !isOverflow(acc)) {
+            markOverflow(acc, maxNumericIndex(acc, getMaxIndex(source)));
+        }
+        if (isOverflow(acc)) {
+            var keyNum = parseInt(key, 10);
+            if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+                setMaxIndex(acc, keyNum);
+            }
+        }
+        if (isConflict(acc)) {
+            var conflictKey = parseInt(key, 10);
+            if (String(conflictKey) === key && conflictKey > getConflictIndex(acc)) {
+                markConflict(acc, conflictKey);
+            }
+        }
+
+        return acc;
+    }, mergeTarget);
+};
+
+var assign = function assignSingleSource(target, source) {
+    return Object.keys(source).reduce(function (acc, key) {
+        setProperty(acc, key, source[key]);
+        return acc;
+    }, target);
+};
+
+var decode = function (str, defaultDecoder, charset) {
+    // With no `%` there is no escape to expand, in either charset: `unescape` has
+    // nothing to match, and `decodeURIComponent` is the identity on such a string
+    // (and cannot throw). So only `+` -> ' ' remains, and often not even that.
+    if (typeof str === 'string' && str.indexOf('%') === -1) {
+        return str.indexOf('+') === -1 ? str : str.replace(/\+/g, ' ');
+    }
+
+    var strWithoutPlus = str.replace(/\+/g, ' ');
+    if (charset === 'iso-8859-1') {
+        // unescape never throws, no try...catch needed:
+        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+    }
+    // utf-8
+    try {
+        return decodeURIComponent(strWithoutPlus);
+    } catch (e) {
+        return strWithoutPlus;
+    }
+};
+
+var hasToPrimitive = typeof Symbol === 'function' && typeof Symbol.toPrimitive === 'symbol';
+var arrayJoin = Array.prototype.join;
+var arrayToString = Array.prototype.toString;
+var objectToString = Object.prototype.toString;
+
+// an object with no callable toString (eg, from JSON, or null-prototype) would make String() or join() throw,
+// so it becomes its primitive valueOf or else Object.prototype.toString; arrays are walked like join walks them,
+// copied only once an element changes, with an array already being joined becoming '' as engines do for cycles
+var toCoercible = function toCoercible(value, joining) {
+    if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
+        return value;
+    }
+    if (hasToPrimitive && value[Symbol.toPrimitive] != null) {
+        return value;
+    }
+    if (isArray(value) && value.toString === arrayToString && value.join === arrayJoin) {
+        var ancestors = joining || getSideChannel();
+        if (ancestors.has(value)) {
+            return '';
+        }
+        ancestors.set(value, true);
+        var copy;
+        for (var i = 0; i < value.length; i += 1) {
+            var item = value[i];
+            var coerced = toCoercible(item, ancestors);
+            if (!copy && coerced !== item) {
+                copy = [];
+                for (var j = 0; j < i; j += 1) {
+                    copy[j] = value[j];
+                }
+            }
+            if (copy) {
+                copy[i] = coerced;
+            }
+        }
+        ancestors['delete'](value);
+        return copy || value;
+    }
+    if (typeof value.toString === 'function') {
+        return value;
+    }
+    var valueOf = value.valueOf;
+    if (typeof valueOf === 'function') {
+        var primitive = valueOf.call(value);
+        if (!primitive || (typeof primitive !== 'object' && typeof primitive !== 'function')) {
+            return String(primitive);
+        }
+    }
+    return objectToString.call(value);
+};
+
+var limit = 1024;
+
+/* eslint operator-linebreak: [2, "before"] */
+
+var encode = function encode(str, defaultEncoder, charset, kind, format) {
+    // This code was originally written by Brian White (mscdex) for the io.js core querystring library.
+    // It has been adapted here for stricter adherence to RFC 3986
+    if (str.length === 0) {
+        return str;
+    }
+
+    var string = str;
+    if (typeof str === 'symbol') {
+        string = Symbol.prototype.toString.call(str);
+    } else if (typeof str !== 'string') {
+        string = String(toCoercible(str));
+    }
+
+    if (charset === 'iso-8859-1') {
+        // `escape` leaves `+` untouched, but a literal `+` is decoded back to a space,
+        // so it must be percent-encoded to round-trip (the utf-8 path already does this).
+        return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+            return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+        }).replace(/\+/g, '%2B');
+    }
+
+    var out = '';
+    for (var j = 0; j < string.length; j += limit) {
+        var segment = string.length >= limit ? string.slice(j, j + limit) : string;
+        if (j + limit < string.length) {
+            var last = segment.charCodeAt(segment.length - 1);
+            if (last >= 0xD800 && last <= 0xDBFF) {
+                segment = segment.slice(0, -1);
+                j -= 1;
+            }
+        }
+        var arr = [];
+
+        for (var i = 0; i < segment.length; ++i) {
+            var c = segment.charCodeAt(i);
+            if (
+                c === 0x2D // -
+                || c === 0x2E // .
+                || c === 0x5F // _
+                || c === 0x7E // ~
+                || (c >= 0x30 && c <= 0x39) // 0-9
+                || (c >= 0x41 && c <= 0x5A) // a-z
+                || (c >= 0x61 && c <= 0x7A) // A-Z
+                || (format === formats.RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+            ) {
+                arr[arr.length] = segment.charAt(i);
+                continue;
+            }
+
+            if (c < 0x80) {
+                arr[arr.length] = hexTable[c];
+                continue;
+            }
+
+            if (c < 0x800) {
+                arr[arr.length] = hexTable[0xC0 | (c >> 6)]
+                    + hexTable[0x80 | (c & 0x3F)];
+                continue;
+            }
+
+            if (c < 0xD800 || c >= 0xE000) {
+                arr[arr.length] = hexTable[0xE0 | (c >> 12)]
+                    + hexTable[0x80 | ((c >> 6) & 0x3F)]
+                    + hexTable[0x80 | (c & 0x3F)];
+                continue;
+            }
+
+            i += 1;
+            c = 0x10000 + (((c & 0x3FF) << 10) | (segment.charCodeAt(i) & 0x3FF));
+
+            arr[arr.length] = hexTable[0xF0 | (c >> 18)]
+                + hexTable[0x80 | ((c >> 12) & 0x3F)]
+                + hexTable[0x80 | ((c >> 6) & 0x3F)]
+                + hexTable[0x80 | (c & 0x3F)];
+        }
+
+        out += arr.join('');
+    }
+
+    return out;
+};
+
+var compact = function compact(value) {
+    var queue = [{ obj: { o: value }, prop: 'o' }];
+    var refs = getSideChannel();
+
+    for (var i = 0; i < queue.length; ++i) {
+        var item = queue[i];
+        var obj = item.obj[item.prop];
+
+        var keys = Object.keys(obj);
+        for (var j = 0; j < keys.length; ++j) {
+            var key = keys[j];
+            var val = obj[key];
+            if (typeof val === 'object' && val !== null && !refs.has(val)) {
+                queue[queue.length] = { obj: obj, prop: key };
+                refs.set(val, true);
+            }
+        }
+    }
+
+    compactQueue(queue);
+
+    return value;
+};
+
+var isRegExp = function isRegExp(obj) {
+    return Object.prototype.toString.call(obj) === '[object RegExp]';
+};
+
+var isBuffer = function isBuffer(obj) {
+    if (!obj || typeof obj !== 'object') {
+        return false;
+    }
+
+    return !!(obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj));
+};
+
+var combine = function combine(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
+    // If 'a' is already an overflow object, add to it
+    if (isOverflow(a)) {
+        if (throwOnLimitExceeded) {
+            throw new RangeError('Array limit exceeded. Only ' + arrayLimit + ' element' + (arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+        }
+        // spread `b` one level, matching the `[].concat(a, b)` used below, so a
+        // collection appended to an already-overflowed object is flattened
+        // rather than nested under a single index
+        var bValues = isArray(b) ? b : [b];
+        var newIndex = getMaxIndex(a);
+        for (var i = 0; i < bValues.length; ++i) {
+            newIndex += 1;
+            a[newIndex] = bValues[i];
+        }
+        setMaxIndex(a, newIndex);
+        return a;
+    }
+
+    var result = [].concat(a, b);
+    if (result.length > arrayLimit) {
+        if (throwOnLimitExceeded) {
+            throw new RangeError('Array limit exceeded. Only ' + arrayLimit + ' element' + (arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+        }
+        return markOverflow(arrayToObject(result, { plainObjects: plainObjects }), result.length - 1);
+    }
+    return result;
+};
+
+var maybeMap = function maybeMap(val, fn) {
+    if (isArray(val)) {
+        var mapped = [];
+        for (var i = 0; i < val.length; i += 1) {
+            mapped[mapped.length] = fn(val[i]);
+        }
+        return mapped;
+    }
+    return fn(val);
+};
+
+module.exports = {
+    arrayToObject: arrayToObject,
+    assign: assign,
+    combine: combine,
+    compact: compact,
+    decode: decode,
+    encode: encode,
+    isBuffer: isBuffer,
+    isOverflow: isOverflow,
+    isRegExp: isRegExp,
+    markOverflow: markOverflow,
+    maybeMap: maybeMap,
+    merge: merge,
+    toCoercible: toCoercible
+};

.pnpm-store/v11/files/5d/4784a2d770f4bed3983b2584862f924fa5e5faf8357653b3770cffd48c2a82752e5948c20122a8f1c5eee0aaa925717194060d9c7a71c1e326194e18809b01

@@ -0,0 +1,140 @@
+# `@humanfs/core`
+
+by [Nicholas C. Zakas](https://humanwhocodes.com)
+
+If you find this useful, please consider supporting my work with a [donation](https://humanwhocodes.com/donate) or [nominate me](https://stars.github.com/nominate/) for a GitHub Star.
+
+## Description
+
+The core functionality for humanfs that is shared across all implementations for all runtimes. The contents of this package are intentionally runtime agnostic and are not intended to be used alone.
+
+Currently, this package simply exports the `Hfs` class, which is an abstract base class intended to be inherited from in runtime-specific hfs packages (like `@humanfs/node`).
+
+> [!WARNING]
+> This project is **experimental** and may change significantly before v1.0.0. Use at your own caution and definitely not in production!
+
+## Installation
+
+### Node.js
+
+Install using your favorite package manager for Node.js:
+
+```shell
+npm install @humanfs/core
+
+# or
+
+pnpm install @humanfs/core
+
+# or
+
+yarn add @humanfs/core
+
+# or
+
+bun install @humanfs/core
+```
+
+Then you can import the `Hfs` and `Path` classes like this:
+
+```js
+import { Hfs, Path } from "@humanfs/core";
+```
+
+### Deno
+
+Install using [JSR](https://jsr.io):
+
+```shell
+deno add @humanfs/core
+
+# or
+
+jsr add @humanfs/core
+```
+
+Then you can import the `Hfs` class like this:
+
+```js
+import { Hfs, Path } from "@humanfs/core";
+```
+
+### Browser
+
+It's recommended to import the minified version to save bandwidth:
+
+```js
+import { Hfs, Path } from "https://cdn.skypack.dev/@humanfs/core?min";
+```
+
+However, you can also import the unminified version for debugging purposes:
+
+```js
+import { Hfs, Path } from "https://cdn.skypack.dev/@humanfs/core";
+```
+
+## Usage
+
+### `Hfs` Class
+
+The `Hfs` class contains all of the basic functionality for an `Hfs` instance *without* a predefined impl. This class is mostly used for creating runtime-specific impls, such as `NodeHfs` and `DenoHfs`.
+
+You can create your own instance by providing an `impl` directly:
+
+```js
+const hfs = new Hfs({ impl: { async text() {} }});
+```
+
+The specified `impl` becomes the base impl for the instance, meaning you can always reset back to it using `resetImpl()`.
+
+You can also inherit from `Hfs` to create your own class with a preconfigured impl, such as:
+
+```js
+class MyHfs extends Hfs {
+	constructor() {
+		super({
+			impl: myImpl
+		});
+	}
+}
+```
+
+### `Path` Class
+
+The `Path` class represents the path to a directory or file within a file system. It's an abstract representation that can be used even outside of traditional file systems where string paths might not make sense.
+
+```js
+const myPath = new Path(["dir", "subdir"]);
+console.log(myPath.toString());		// "dir/subdir"
+
+// add another step
+myPath.push("file.txt");
+console.log(myPath.toString());		// "dir/subdir/file.txt"
+
+// get just the last step
+console.log(myPath.name);			// "file.txt"
+
+// change just the last step
+myPath.name = "file.json";
+console.log(myPath.name);			// "file.json"
+console.log(myPath.toString());		// "dir/subdir/file.json"
+
+// get the size of the path
+console.log(myPath.size);			// 3
+
+// remove the last step
+myPath.pop();
+console.log(myPath.toString());		// "dir/subdir"
+
+// iterate over the steps
+for (const step of myPath) {
+	// do something
+}
+
+// create a new path from a string
+const newPath = Path.fromString("/foo/bar");
+```
+
+## License
+
+Apache 2.0

.pnpm-store/v11/files/5d/48a346c29f1453173615bfb225d8d4422a36fe4ec3a64cd4c09ac8deee6b9c71da15672fb2ea680d114eeae50c3130e67cf44f366def4750d1846c2ad39256

@@ -0,0 +1,109 @@
+#ifndef EVENT_H
+#define EVENT_H
+
+#include <string>
+#include <node_api.h>
+#include "wasm/include.h"
+#include <napi.h>
+#include <mutex>
+#include <map>
+#include <optional>
+
+using namespace Napi;
+
+struct Event {
+  std::string path;
+  bool isCreated;
+  bool isDeleted;
+  Event(std::string path) : path(path), isCreated(false), isDeleted(false) {}
+
+  Value toJS(const Env& env) {
+    EscapableHandleScope scope(env);
+    Object res = Object::New(env);
+    std::string type = isCreated ? "create" : isDeleted ? "delete" : "update";
+    res.Set(String::New(env, "path"), String::New(env, path.c_str()));
+    res.Set(String::New(env, "type"), String::New(env, type.c_str()));
+    return scope.Escape(res);
+  }
+};
+
+class EventList {
+public:
+  void create(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    Event *event = internalUpdate(path);
+    if (event->isDeleted) {
+      // Assume update event when rapidly removed and created
+      // https://github.com/parcel-bundler/watcher/issues/72
+      event->isDeleted = false;
+    } else {
+      event->isCreated = true;
+    }
+  }
+
+  Event *update(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    return internalUpdate(path);
+  }
+
+  void remove(std::string path) {
+    std::lock_guard<std::mutex> l(mMutex);
+    Event *event = internalUpdate(path);
+    event->isDeleted = true;
+  }
+
+  size_t size() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mEvents.size();
+  }
+
+  std::vector<Event> getEvents() {
+    std::lock_guard<std::mutex> l(mMutex);
+    std::vector<Event> eventsCloneVector;
+    for(auto it = mEvents.begin(); it != mEvents.end(); ++it) {
+      if (!(it->second.isCreated && it->second.isDeleted)) {
+        eventsCloneVector.push_back(it->second);
+      }
+    }
+    return eventsCloneVector;
+  }
+
+  void clear() {
+    std::lock_guard<std::mutex> l(mMutex);
+    mEvents.clear();
+    mError.reset();
+  }
+
+  void error(std::string err) {
+    std::lock_guard<std::mutex> l(mMutex);
+    if (!mError.has_value()) {
+      mError.emplace(err);
+    }
+  }
+
+  bool hasError() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mError.has_value();
+  }
+
+  std::string getError() {
+    std::lock_guard<std::mutex> l(mMutex);
+    return mError.value_or("");
+  }
+
+private:
+  mutable std::mutex mMutex;
+  std::map<std::string, Event> mEvents;
+  std::optional<std::string> mError;
+  Event *internalUpdate(std::string path) {
+    auto found = mEvents.find(path);
+    if (found == mEvents.end()) {
+      auto it = mEvents.emplace(path, Event(path));
+      return &it.first->second;
+    }
+
+    return &found->second;
+  }
+};
+
+#endif

.pnpm-store/v11/files/5d/55c4c5181e221dea3c1286645f7a2edec5ccad9e4104274e88cabd4a663c05155d78f10f902ce6237178581ff78e8d1aeb5fddd6c184dafaefa24a46ca1dd2

@@ -0,0 +1 @@
+{"version":3,"names":["_index","require","removeComments","node","COMMENT_KEYS","forEach","key"],"sources":["../../src/comments/removeComments.ts"],"sourcesContent":["import { COMMENT_KEYS } from \"../constants/index.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Remove comment properties from a node.\n */\nexport default function removeComments<T extends t.Node>(node: T): T {\n  COMMENT_KEYS.forEach(key => {\n    node[key] = null;\n  });\n\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAMe,SAASC,cAAcA,CAAmBC,IAAO,EAAK;EACnEC,mBAAY,CAACC,OAAO,CAACC,GAAG,IAAI;IAC1BH,IAAI,CAACG,GAAG,CAAC,GAAG,IAAI;EAClB,CAAC,CAAC;EAEF,OAAOH,IAAI;AACb","ignoreList":[]}

.pnpm-store/v11/files/5d/5bb50712e1011745702f61a3e7e58709dc786da057c923948eea1301f67c3d59a2611066c62342168e89e246fe808df5085f39bb017cc9649b5e5941005e8d

@@ -0,0 +1,420 @@
+export default `flf2a$ 4 3 11 1 11 0 16769 0
+Author : 
+Date   : 2008/8/28 1:12:58
+Version: 1.0
+-------------------------------------------------
+
+-------------------------------------------------
+This font has been created using JavE's FIGlet font export assistant.
+Have a look at: http://www.jave.de
+
+Permission is hereby given to modify this font, as long as the
+modifier's name is placed on a comment line.
+$ $#
+$ $#
+$ $#
+$ $##
+!#
+$#
+$#
+$##
+"#
+$#
+$#
+$##
+##
+$#
+$#
+$##
+$#
+$#
+$#
+$##
+%#
+$#
+$#
+$##
+&#
+$#
+$#
+$##
+'#
+$#
+$#
+$##
+(#
+$#
+$#
+$##
+)#
+$#
+$#
+$##
+*#
+$#
+$#
+$##
++#
+$#
+$#
+$##
+,#
+$#
+$#
+$##
+-#
+$#
+$#
+$##
+.#
+$#
+$#
+$##
+/#
+$#
+$#
+$##
+0#
+$#
+$#
+$##
+1#
+$#
+$#
+$##
+2#
+$#
+$#
+$##
+3#
+$#
+$#
+$##
+4#
+$#
+$#
+$##
+5#
+$#
+$#
+$##
+6#
+$#
+$#
+$##
+7#
+$#
+$#
+$##
+8#
+$#
+$#
+$##
+9#
+$#
+$#
+$##
+:#
+$#
+$#
+$##
+;#
+$#
+$#
+$##
+<#
+$#
+$#
+$##
+=#
+$#
+$#
+$##
+>#
+$#
+$#
+$##
+?#
+$#
+$#
+$##
+@#
+$#
+$#
+$##
+ ___, $#
+(-|_\\_,#
+ _|  )$#
+(     $##
+ ___,$#
+(-|_)$#
+ _|__)#
+(    $##
+ ____ $#
+(-/  \`$#
+  \\___,#
+      $##
+ ____,#
+(-|  \\#
+ _|__/#
+(    $##
+ ____,#
+(-|_,$#
+ _|__,#
+(    $##
+ ____,#
+(-|_,$#
+ _|  $#
+(    $##
+ ____  $#
+(-/  \`_,#
+  \\___)$#
+       $##
+ __   _,#
+(-|__| $#
+ _|  |_,#
+(      $##
+ ____,#
+(-|  $#
+ _|__,#
+(    $##
+  ____,#
+ (-|  $#
+ _ |  $#
+(__/  $##
+ __  _,#
+(-|_/ $#
+ _| \\_,#
+(     $##
+ __  $#
+(-|  $#
+ _|__,#
+(    $##
+ _____, $#
+(-| | | $#
+ _| | |_,#
+(       $##
+ ____, $#
+(-|  | $#
+ _|  |_,#
+(      $##
+ ____,#
+(-/  \\#
+  \\__/#
+     $##
+ ___,#
+(-|_)#
+ _| $#
+(   $##
+ ____, $#
+(-/  \\ $#
+  \\__\\_,#
+       $##
+ ___, $#
+(-|_) $#
+ _| \\_,#
+(     $##
+ ____$#
+(-(__\`#
+ ____)#
+(    $##
+ ____,#
+(-|  $#
+ _|  $#
+(    $##
+ __   _,#
+(-|  | $#
+  |__|_,#
+       $##
+ __  _,#
+(-\\ | $#
+   \\| $#
+      $##
+ __    _,#
+(-| | | $#
+ _|_|_| $#
+(       $##
+ _   __,#
+(-\\_/  $#
+ _/ \\_,$#
+(      $##
+  __  _,#
+ (-\\ | $#
+    \\| $#
+  (__/ $##
+  ___,$#
+ (- / $#
+  ,/__,#
+      $##
+[#
+$#
+$#
+$##
+\\#
+$#
+$#
+$##
+]#
+$#
+$#
+$##
+^#
+$#
+$#
+$##
+_#
+$#
+$#
+$##
+\`#
+$#
+$#
+$##
+ ___, $#
+(-|_\\_,#
+ _|  )$#
+(     $##
+ ___,$#
+(-|_)$#
+ _|__)#
+(    $##
+ ____ $#
+(-/  \`$#
+  \\___,#
+      $##
+ ____,#
+(-|  \\#
+ _|__/#
+(    $##
+ ____,#
+(-|_,$#
+ _|__,#
+(    $##
+ ____,#
+(-|_,$#
+ _|  $#
+(    $##
+ ____  $#
+(-/  \`_,#
+  \\___)$#
+       $##
+ __   _,#
+(-|__| $#
+ _|  |_,#
+(      $##
+ ____,#
+(-|  $#
+ _|__,#
+(    $##
+  ____,#
+ (-|  $#
+ _ |  $#
+(__/  $##
+ __  _,#
+(-|_/ $#
+ _| \\_,#
+(     $##
+ __  $#
+(-|  $#
+ _|__,#
+(    $##
+ _____, $#
+(-| | | $#
+ _| | |_,#
+(       $##
+ ____, $#
+(-|  | $#
+ _|  |_,#
+(      $##
+ ____,#
+(-/  \\#
+  \\__/#
+     $##
+ ___,#
+(-|_)#
+ _| $#
+(   $##
+ ____, $#
+(-/  \\ $#
+  \\__\\_,#
+       $##
+ ___, $#
+(-|_) $#
+ _| \\_,#
+(     $##
+ ____$#
+(-(__\`#
+ ____)#
+(    $##
+ ____,#
+(-|  $#
+ _|  $#
+(    $##
+ __   _,#
+(-|  | $#
+  |__|_,#
+       $##
+ __  _,#
+(-\\ | $#
+   \\| $#
+      $##
+ __    _,#
+(-| | | $#
+ _|_|_| $#
+(       $##
+ _   __,#
+(-\\_/  $#
+ _/ \\_,$#
+(      $##
+  __  _,#
+ (-\\ | $#
+    \\| $#
+  (__/ $##
+  ___,$#
+ (- / $#
+  ,/__,#
+      $##
+{#
+$#
+$#
+$##
+|#
+$#
+$#
+$##
+}#
+$#
+$#
+$##
+~#
+$#
+$#
+$##
+ ___,  $#
+(-|_\\_,$#
+ _|  ) $#
+(      $##
+ ____,$#
+(-/  \\$#
+  \\__/$#
+      $##
+ __   _,$#
+(-|  |  $#
+  |__|_,$#
+        $##
+ ___,  $#
+(-|_\\_,$#
+ _|  ) $#
+(      $##
+ ____,$#
+(-/  \\$#
+  \\__/$#
+      $##
+ __   _,$#
+(-|  |  $#
+  |__|_,$#
+        $##
+�#
+$#
+$#
+$##`

.pnpm-store/v11/files/5d/5eb9ccf01a5be79b40f0cd157cbc6e2c20d88c3d499422026fbff7aeda999fee25fd52fa6bc5b202e2aaa7de3602be005c65235cb1f2e59f2737854ca17da8

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arjun Barrett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.pnpm-store/v11/files/5d/6f6aa3308c65e2a61b5cb0797795237320d0685392c5483ef43849fea9188e44a8408af4332ee32b152b49631c2790024c5eda4dbaea996b809b1d2761f85c

@@ -0,0 +1,17 @@
+/**
+ * @license lucide-react v0.469.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+import createLucideIcon from '../createLucideIcon.js';
+
+const Goal = createLucideIcon("Goal", [
+  ["path", { d: "M12 13V2l8 4-8 4", key: "5wlwwj" }],
+  ["path", { d: "M20.561 10.222a9 9 0 1 1-12.55-5.29", key: "1c0wjv" }],
+  ["path", { d: "M8.002 9.997a5 5 0 1 0 8.9 2.02", key: "gb1g7m" }]
+]);
+
+export { Goal as default };
+//# sourceMappingURL=goal.js.map

.pnpm-store/v11/files/5d/712fed073b29480ed11bf302d6dc75199e451ec2320cd3bdd7b4859b70b8d21b657a2b51d406d943a000e875cb1af3dbfc9708d6299321b14b1ac0cfa724ba

@@ -0,0 +1,3 @@
+import * as z from "./external.cjs";
+export * from "./external.cjs";
+export { z };

.pnpm-store/v11/files/5d/72ef2a90423ee82ad74c041c670bf80ff8e71be3f9f02de03309d9881a4ec9c725ce21c63773a0191490a8ec4a6b3ae184f84674193ff8ed75b9b5d97fd6de

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/tooltip.tsx"],
+  "sourcesContent": ["import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { DismissableLayer } from '@radix-ui/react-dismissable-layer';\nimport { useId } from '@radix-ui/react-id';\nimport * as PopperPrimitive from '@radix-ui/react-popper';\nimport { createPopperScope } from '@radix-ui/react-popper';\nimport { Portal as PortalPrimitive } from '@radix-ui/react-portal';\nimport { Presence } from '@radix-ui/react-presence';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { createSlottable } from '@radix-ui/react-slot';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';\n\nimport type { Scope } from '@radix-ui/react-context';\n\ntype ScopedProps<P = {}> = P & { __scopeTooltip?: Scope };\nconst [createTooltipContext, createTooltipScope] = createContextScope('Tooltip', [\n  createPopperScope,\n]);\nconst usePopperScope = createPopperScope();\n\n/* -------------------------------------------------------------------------------------------------\n * TooltipProvider\n * -----------------------------------------------------------------------------------------------*/\n\nconst PROVIDER_NAME = 'TooltipProvider';\nconst DEFAULT_DELAY_DURATION = 700;\nconst TOOLTIP_OPEN = 'tooltip.open';\n\ntype TooltipProviderContextValue = {\n  isOpenDelayedRef: React.MutableRefObject<boolean>;\n  delayDuration: number;\n  onOpen(): void;\n  onClose(): void;\n  onPointerInTransitChange(inTransit: boolean): void;\n  isPointerInTransitRef: React.MutableRefObject<boolean>;\n  disableHoverableContent: boolean;\n};\n\nconst [TooltipProviderContextProvider, useTooltipProviderContext] =\n  createTooltipContext<TooltipProviderContextValue>(PROVIDER_NAME);\n\ninterface TooltipProviderProps {\n  children: React.ReactNode;\n  /**\n   * The duration from when the pointer enters the trigger until the tooltip gets opened.\n   * @defaultValue 700\n   */\n  delayDuration?: number;\n  /**\n   * How much time a user has to enter another trigger without incurring a delay again.\n   * @defaultValue 300\n   */\n  skipDelayDuration?: number;\n  /**\n   * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.\n   * @defaultValue false\n   */\n  disableHoverableContent?: boolean;\n}\n\nconst TooltipProvider: React.FC<TooltipProviderProps> = (\n  props: ScopedProps<TooltipProviderProps>\n) => {\n  const {\n    __scopeTooltip,\n    delayDuration = DEFAULT_DELAY_DURATION,\n    skipDelayDuration = 300,\n    disableHoverableContent = false,\n    children,\n  } = props;\n  const isOpenDelayedRef = React.useRef(true);\n  const isPointerInTransitRef = React.useRef(false);\n  const skipDelayTimerRef = React.useRef(0);\n\n  React.useEffect(() => {\n    const skipDelayTimer = skipDelayTimerRef.current;\n    return () => window.clearTimeout(skipDelayTimer);\n  }, []);\n\n  return (\n    <TooltipProviderContextProvider\n      scope={__scopeTooltip}\n      isOpenDelayedRef={isOpenDelayedRef}\n      delayDuration={delayDuration}\n      onOpen={React.useCallback(() => {\n        window.clearTimeout(skipDelayTimerRef.current);\n        isOpenDelayedRef.current = false;\n      }, [])}\n      onClose={React.useCallback(() => {\n        window.clearTimeout(skipDelayTimerRef.current);\n        skipDelayTimerRef.current = window.setTimeout(\n          () => (isOpenDelayedRef.current = true),\n          skipDelayDuration\n        );\n      }, [skipDelayDuration])}\n      isPointerInTransitRef={isPointerInTransitRef}\n      onPointerInTransitChange={React.useCallback((inTransit: boolean) => {\n        isPointerInTransitRef.current = inTransit;\n      }, [])}\n      disableHoverableContent={disableHoverableContent}\n    >\n      {children}\n    </TooltipProviderContextProvider>\n  );\n};\n\nTooltipProvider.displayName = PROVIDER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * Tooltip\n * -----------------------------------------------------------------------------------------------*/\n\nconst TOOLTIP_NAME = 'Tooltip';\n\ntype TooltipContextValue = {\n  contentId: string;\n  open: boolean;\n  stateAttribute: 'closed' | 'delayed-open' | 'instant-open';\n  trigger: TooltipTriggerElement | null;\n  onTriggerChange(trigger: TooltipTriggerElement | null): void;\n  onTriggerEnter(): void;\n  onTriggerLeave(): void;\n  onOpen(): void;\n  onClose(): void;\n  disableHoverableContent: boolean;\n};\n\nconst [TooltipContextProvider, useTooltipContext] =\n  createTooltipContext<TooltipContextValue>(TOOLTIP_NAME);\n\ninterface TooltipProps {\n  children?: React.ReactNode;\n  open?: boolean;\n  defaultOpen?: boolean;\n  onOpenChange?: (open: boolean) => void;\n  /**\n   * The durationLine truncated
+  "mappings": ";;;AAAA,YAAY,WAAW;AACvB,SAAS,4BAA4B;AACrC,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AACjC,SAAS,aAAa;AACtB,YAAY,qBAAqB;AACjC,SAAS,yBAAyB;AAClC,SAAS,UAAU,uBAAuB;AAC1C,SAAS,gBAAgB;AACzB,SAAS,iBAAiB;AAC1B,SAAS,uBAAuB;AAChC,SAAS,4BAA4B;AACrC,YAAY,6BAA6B;AAsErC,cAgdI,YAhdJ;AAjEJ,IAAM,CAAC,sBAAsB,kBAAkB,IAAI,mBAAmB,WAAW;AAAA,EAC/E;AACF,CAAC;AACD,IAAM,iBAAiB,kBAAkB;AAMzC,IAAM,gBAAgB;AACtB,IAAM,yBAAyB;AAC/B,IAAM,eAAe;AAYrB,IAAM,CAAC,gCAAgC,yBAAyB,IAC9D,qBAAkD,aAAa;AAqBjE,IAAM,kBAAkD,CACtD,UACG;AACH,QAAM;AAAA,IACJ;AAAA,IACA,gBAAgB;AAAA,IAChB,oBAAoB;AAAA,IACpB,0BAA0B;AAAA,IAC1B;AAAA,EACF,IAAI;AACJ,QAAM,mBAAyB,aAAO,IAAI;AAC1C,QAAM,wBAA8B,aAAO,KAAK;AAChD,QAAM,oBAA0B,aAAO,CAAC;AAExC,EAAM,gBAAU,MAAM;AACpB,UAAM,iBAAiB,kBAAkB;AACzC,WAAO,MAAM,OAAO,aAAa,cAAc;AAAA,EACjD,GAAG,CAAC,CAAC;AAEL,SACE;AAAA,IAAC;AAAA;AAAA,MACC,OAAO;AAAA,MACP;AAAA,MACA;AAAA,MACA,QAAc,kBAAY,MAAM;AAC9B,eAAO,aAAa,kBAAkB,OAAO;AAC7C,yBAAiB,UAAU;AAAA,MAC7B,GAAG,CAAC,CAAC;AAAA,MACL,SAAe,kBAAY,MAAM;AAC/B,eAAO,aAAa,kBAAkB,OAAO;AAC7C,0BAAkB,UAAU,OAAO;AAAA,UACjC,MAAO,iBAAiB,UAAU;AAAA,UAClC;AAAA,QACF;AAAA,MACF,GAAG,CAAC,iBAAiB,CAAC;AAAA,MACtB;AAAA,MACA,0BAAgC,kBAAY,CAAC,cAAuB;AAClE,8BAAsB,UAAU;AAAA,MAClC,GAAG,CAAC,CAAC;AAAA,MACL;AAAA,MAEC;AAAA;AAAA,EACH;AAEJ;AAEA,gBAAgB,cAAc;AAM9B,IAAM,eAAe;AAerB,IAAM,CAAC,wBAAwB,iBAAiB,IAC9C,qBAA0C,YAAY;AAoBxD,IAAM,UAAkC,CAAC,UAAqC;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,yBAAyB;AAAA,IACzB,eAAe;AAAA,EACjB,IAAI;AACJ,QAAM,kBAAkB,0BAA0B,cAAc,MAAM,cAAc;AACpF,QAAM,cAAc,eAAe,cAAc;AACjD,QAAM,CAAC,SAAS,UAAU,IAAU,eAAmC,IAAI;AAC3E,QAAM,YAAY,MAAM;AACxB,QAAM,eAAqB,aAAO,CAAC;AACnC,QAAM,0BACJ,+BAA+B,gBAAgB;AACjD,QAAM,gBAAgB,qBAAqB,gBAAgB;AAC3D,QAAM,oBAA0B,aAAO,KAAK;AAC5C,QAAM,CAAC,MAAM,OAAO,IAAI,qBAAqB;AAAA,IAC3C,MAAM;AAAA,IACN,aAAa,eAAe;AAAA,IAC5B,UAAU,CAACA,UAAS;AAClB,UAAIA,OAAM;AACR,wBAAgB,OAAO;AAIvB,iBAAS,cAAc,IAAI,YAAY,YAAY,CAAC;AAAA,MACtD,OAAO;AACL,wBAAgB,QAAQ;AAAA,MAC1B;AACA,qBAAeA,KAAI;AAAA,IACrB;AAAA,IACA,QAAQ;AAAA,EACV,CAAC;AACD,QAAM,iBAAuB,cAAQ,MAAM;AACzC,WAAO,OAAQ,kBAAkB,UAAU,iBAAiB,iBAAkB;AAAA,EAChF,GAAG,CAAC,IAAI,CAAC;AAET,QAAM,aAAmB,kBAAY,MAAM;AACzC,WAAO,aAAa,aAAa,OAAO;AACxC,iBAAa,UAAU;AACvB,sBAAkB,UAAU;AAC5B,YAAQ,IAAI;AAAA,EACd,GAAG,CAAC,OAAO,CAAC;AAEZ,QAAM,cAAoB,kBAAY,MAAM;AAC1C,WAAO,aAAa,aAAa,OAAO;AACxC,iBAAa,UAAU;AACvB,YAAQ,KAAK;AAAA,EACf,GAAG,CAAC,OAAO,CAAC;AAEZ,QAAM,oBAA0B,kBAAY,MAAM;AAChD,WAAO,aAAa,aAAa,OAAO;AACxC,iBAAa,UAAU,OAAO,WAAW,MAAM;AAC7C,wBAAkB,UAAU;AAC5B,cAAQ,IAAI;AACZ,mBAAa,UAAU;AAAA,IACzB,GAAG,aAAa;AAAA,EAClB,GAAG,CAAC,eAAe,OAAO,CAAC;AAE3B,EAAM,gBAAU,MAAM;AACpB,WAAO,MAAM;AACX,UAAI,aAAa,SAAS;AACxB,eAAO,aAAa,aAAa,OAAO;AACxC,qBAAa,UAAU;AAAA,MACzB;AAAA,IACF;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SACE,oBAAiB,sBAAhB,EAAsB,GAAG,aACxB;AAAA,IAAC;AAAA;AAAA,MACC,OAAO;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,iBAAiB;AAAA,MACjB,gBAAsB,kBAAY,MAAM;AACtC,YAAI,gBAAgB,iBAAiB,QAAS,mBAAkB;AAAA,YAC3D,YAAW;AAAA,MAClB,GAAG,CAAC,gBAAgB,kBAAkB,mBAAmB,UAAU,CAAC;AAAA,MACpE,gBAAsB,kBAAY,MAAM;AACtC,YAAI,yBAAyB;AAC3B,sBAAY;AAAA,QACd,OAAO;AAEL,iBAAO,aAAa,aAAa,OAAO;AACxC,uBAAa,UAAU;AAAA,QACzB;AAAA,MACF,GAAG,CAAC,aAAa,uBAAuB,CAAC;AAAA,MACzC,QAAQ;AAAA,MACR,SAAS;AAAA,MACT;AAAA,MAEC;AAAA;AAAA,EACH,GACF;AAEJ;AAEA,QAAQ,cAAc;AAMtB,IAAM,eAAe;AAMrB,IAAM,iBAAuB;AAAA,EAC3B,CAAC,OAAyC,iBAAiB;AACzD,UAAM,EAAE,gBAAgB,GAAG,aAAa,IAAI;AAC5C,UAAM,UAAU,kBAAkB,cAAc,cAAc;AAC9D,UAAM,kBAAkB,0BAA0B,cAAc,cAAc;AAC9E,UAAM,cAAc,eAAe,cAAc;AACjD,UAAM,MAAY,aAA8B,IAAI;AACpD,UAAM,eAAe,gBAAgB,cAAc,KAAK,QAAQ,eAAe;AAC/E,UAAM,mBAAyB,aAAO,KAAK;AAC3C,UAAM,0BAAgC,aAAO,KAAK;AAClD,UAAM,kBAAwB,kBAAY,MAAO,iBAAiB,UAAU,OAAQ,CAAC,CAAC;AAEtF,IAAM,gBAAU,MAAM;AACpB,aAAO,MAAM,SAAS,oBAAoB,aAAa,eAAe;AAAA,IACxE,GAAG,CAAC,eAAe,CAAC;AAEpB,WACE,oBAAiB,wBAAhB,EAAuB,SAAO,MAAE,GAAG,aAClC;AAAA,MAAC,UAAU;AAAA,MAAV;AAAA,QAGC,oBAAkB,QAAQ,OAAO,QAAQ,YAAY;AAAA,QACrD,cAAY,QAAQ;AAAA,QACnB,GAAG;AAAA,QACJ,KAAK;AAAA,QACL,eAAe,qBAAqB,MAAM,eAAe,CAAC,UAAU;AAClE,cAAI,MAAM,gBAAgB,QAAS;AACnC,cACE,CAAC,wBAAwB,WACzB,CAAC,gBAAgB,sBAAsB,SACvC;AACA,oBAAQ,eAAe;AACvB,oCAAwB,UAAU;AAAA,UACpC;AAAA,QACF,CAAC;AAAA,QACD,gBAAgB,qBAAqB,MAAM,gBAAgB,MAAM;AAC/D,kBAAQ,eAAe;AACvB,kCAAwB,UAAU;AAAA,QACpC,CAAC;AAAA,QACD,eAAe,qBAAqB,MAAM,eAAe,MAAM;AAC7D,cAAI,QAAQ,MAAM;AAChB,oBAAQ,QAAQ;AAAA,UAClB;AACA,2BAAiB,UAAU;AAC3B,mBAAS,iBAAiB,aAAa,iBAAiB,EAAE,MAAM,KAAK,CAAC;AAAA,QACxE,CAAC;AAAA,QACD,SAAS,qBAAqB,MAAM,SAAS,MAAM;AACjD,cAAI,CAAC,iBAAiB,QAAS,SAAQ,OAAO;AAAA,QAChD,CAAC;AAAA,QACD,QAAQ,qBAAqB,MAAM,QAAQ,QAAQ,OAAO;AAAA,QAC1D,SAAS,qBAAqB,MAAM,SAAS,QAAQ,OAAO;AAAA;AAAA,IAC9D,GACF;AAAA,EAEJ;AACF;AAEA,eAAe,cAAc;AAM7B,IAAM,cAAc;AAGpB,IAAM,CAAC,gBAAgB,gBAAgB,IAAI,qBAAyC,aAAa;AAAA,EAC/F,YAAY;AACd,CAAC;AAgBD,IAAM,gBAA8C,CAAC,UAA2C;AAC9F,QAAM,EAAE,gBAAgB,YAAY,UAAU,UAAU,IAAI;AAC5D,QAAM,UAAU,kBAAkB,aAAa,cAAc;AAC7D,SACE,oBAAC,kBAAe,OAAO,gBAAgB,YACrC,8BAAC,YAAS,SAAS,cAAc,QAAQ,MACvC,8BAAC,mBAAgB,SAAO,MAAC,WACtB,UACH,GACF,GACF;AAEJ;AAEA,cAAc,cAAc;AAM5B,IAAM,eAAe;AAWrB,IAAM,iBAAuB;AAAA,EAC3B,CAAC,OAAyC,iBAAiB;AACzD,UAAM,gBAAgB,iBAAiB,cAAc,MAAM,cAAc;AACzE,UAAM,EAAE,aAAa,cAAc,YAAY,OAAO,OAAO,GAAG,aAAa,IAAI;AACjF,ULine truncated
+  "names": ["open", "Root", "Content", "Arrow"]
+}

.pnpm-store/v11/files/5d/77397006ea0a14938af2cbe6e08804479191ab1ec4fb8ad09e667a8f98cd8d1b5f25b9b974f1d6d55683df83b8e634728d49eacb8fa5971fb786383d1d286f

@@ -0,0 +1,9 @@
+/**
+ * Type-checked examples for {@link App `App`} and constants in {@link ./app.ts `app.ts`}.
+ *
+ * These examples are included in the API documentation via `@includeCode` tags.
+ * Each function's region markers define the code snippet that appears in the docs.
+ *
+ * @module
+ */
+export {};

.pnpm-store/v11/files/5d/77da585d90e4585832ade581a791d297d12f507c79e0b9912149eacdd4b353f1d463fb468a7fb74ae639b145d5ccc3017e104b894324c5b53059b2cd39dc5f

@@ -0,0 +1 @@
+{"version":3,"file":"attach-function.mjs","sources":["../../../../../src/render/dom/scroll/attach-function.ts"],"sourcesContent":["import { observeTimeline } from \"motion-dom\"\nimport { scrollInfo } from \"./track\"\nimport { OnScroll, OnScrollWithInfo, ScrollOptionsWithDefaults } from \"./types\"\nimport { getTimeline } from \"./utils/get-timeline\"\n\n/**\n * If the onScroll function has two arguments, it's expecting\n * more specific information about the scroll from scrollInfo.\n */\nfunction isOnScrollWithInfo(onScroll: OnScroll): onScroll is OnScrollWithInfo {\n    return onScroll.length === 2\n}\n\nexport function attachToFunction(\n    onScroll: OnScroll,\n    options: ScrollOptionsWithDefaults\n) {\n    if (isOnScrollWithInfo(onScroll)) {\n        return scrollInfo((info) => {\n            onScroll(info[options.axis!].progress, info)\n        }, options)\n    } else {\n        return observeTimeline(onScroll, getTimeline(options))\n    }\n}\n"],"names":[],"mappings":";;;;AAKA;;;AAGG;AACH,SAAS,kBAAkB,CAAC,QAAkB,EAAA;AAC1C,IAAA,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC;AAChC;AAEM,SAAU,gBAAgB,CAC5B,QAAkB,EAClB,OAAkC,EAAA;AAElC,IAAA,IAAI,kBAAkB,CAAC,QAAQ,CAAC,EAAE;AAC9B,QAAA,OAAO,UAAU,CAAC,CAAC,IAAI,KAAI;AACvB,YAAA,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,IAAK,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC;QAChD,CAAC,EAAE,OAAO,CAAC;IACf;SAAO;QACH,OAAO,eAAe,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;IAC1D;AACJ;;;;"}

.pnpm-store/v11/files/5d/782b4d8386a984cb5cbb8f00536044c0ccab1bd3cc0dc23e69923dbc762cb9ed477e2fc680640015083d29a6ef0cbd5e8316d33138dd72b95fd18c95aec6ca

@@ -0,0 +1 @@
+{"version":3,"file":"pickaxe.js","sources":["../../../src/icons/pickaxe.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name Pickaxe\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTQuNTMxIDEyLjQ2OSA2LjYxOSAyMC4zOGExIDEgMCAxIDEtMy0zbDcuOTEyLTcuOTEyIiAvPgogIDxwYXRoIGQ9Ik0xNS42ODYgNC4zMTRBMTIuNSAxMi41IDAgMCAwIDUuNDYxIDIuOTU4IDEgMSAwIDAgMCA1LjU4IDQuNzFhMjIgMjIgMCAwIDEgNi4zMTggMy4zOTMiIC8+CiAgPHBhdGggZD0iTTE3LjcgMy43YTEgMSAwIDAgMC0xLjQgMGwtNC42IDQuNmExIDEgMCAwIDAgMCAxLjRsMi42IDIuNmExIDEgMCAwIDAgMS40IDBsNC42LTQuNmExIDEgMCAwIDAgMC0xLjR6IiAvPgogIDxwYXRoIGQ9Ik0xOS42ODYgOC4zMTRhMTIuNTAxIDEyLjUwMSAwIDAgMSAxLjM1NiAxMC4yMjUgMSAxIDAgMCAxLTEuNzUxLS4xMTkgMjIgMjIgMCAwIDAtMy4zOTMtNi4zMTkiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/pickaxe\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst Pickaxe = createLucideIcon('Pickaxe', [\n  ['path', { d: 'M14.531 12.469 6.619 20.38a1 1 0 1 1-3-3l7.912-7.912', key: 'we99rg' }],\n  [\n    'path',\n    {\n      d: 'M15.686 4.314A12.5 12.5 0 0 0 5.461 2.958 1 1 0 0 0 5.58 4.71a22 22 0 0 1 6.318 3.393',\n      key: '1w6hck',\n    },\n  ],\n  [\n    'path',\n    {\n      d: 'M17.7 3.7a1 1 0 0 0-1.4 0l-4.6 4.6a1 1 0 0 0 0 1.4l2.6 2.6a1 1 0 0 0 1.4 0l4.6-4.6a1 1 0 0 0 0-1.4z',\n      key: '15hgfx',\n    },\n  ],\n  [\n    'path',\n    {\n      d: 'M19.686 8.314a12.501 12.501 0 0 1 1.356 10.225 1 1 0 0 1-1.751-.119 22 22 0 0 0-3.393-6.319',\n      key: '452b4h',\n    },\n  ],\n]);\n\nexport default Pickaxe;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAU,iBAAiB,SAAW,CAAA,CAAA,CAAA;AAAA,CAAA,CAC1C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAwD,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CACrF,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA;AACF,CAAC,CAAA,CAAA;;"}

.pnpm-store/v11/files/5d/78b2e1b320aa1c6b0bf679c355ec2785865bc5e01d8fbf3bfa7fd4c224b5c755b61264b729bd045590becb78a962f4617427bc312580fddf4784b62b07f700

@@ -0,0 +1 @@
+{"version":3,"file":"extract.js","sourceRoot":"","sources":["../../src/extract.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAS;AACT,yDAA0C;AAC1C,sDAAwB;AACxB,uCAAuC;AACvC,uDAA+C;AAE/C,2CAAgD;AAEhD,MAAM,eAAe,GAAG,CAAC,GAAuB,EAAE,EAAE;IAClD,MAAM,CAAC,GAAG,IAAI,sBAAU,CAAC,GAAG,CAAC,CAAA;IAC7B,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAA;IACrB,MAAM,IAAI,GAAG,iBAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC9B,oDAAoD;IACpD,4DAA4D;IAC5D,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,IAAI,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;IACpD,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE;QAC1C,QAAQ,EAAE,QAAQ;QAClB,IAAI,EAAE,IAAI,CAAC,IAAI;KAChB,CAAC,CAAA;IACF,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,WAAW,GAAG,CAAC,GAAmB,EAAE,CAAY,EAAE,EAAE;IACxD,MAAM,CAAC,GAAG,IAAI,kBAAM,CAAC,GAAG,CAAC,CAAA;IACzB,MAAM,QAAQ,GAAG,GAAG,CAAC,WAAW,IAAI,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;IAEpD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAA;IACrB,MAAM,CAAC,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC9C,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;QACrB,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QAEtB,oDAAoD;QACpD,4DAA4D;QAC5D,iBAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE;YACzB,IAAI,EAAE,EAAE,CAAC;gBACP,MAAM,CAAC,EAAE,CAAC,CAAA;YACZ,CAAC;iBAAM,CAAC;gBACN,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE;oBACtC,QAAQ,EAAE,QAAQ;oBAClB,IAAI,EAAE,IAAI,CAAC,IAAI;iBAChB,CAAC,CAAA;gBACF,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;gBAC1B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YAChB,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IACF,OAAO,CAAC,CAAA;AACV,CAAC,CAAA;AAEY,QAAA,OAAO,GAAG,IAAA,6BAAW,EAChC,eAAe,EACf,WAAW,EACX,GAAG,CAAC,EAAE,CAAC,IAAI,sBAAU,CAAC,GAAG,CAAC,EAC1B,GAAG,CAAC,EAAE,CAAC,IAAI,kBAAM,CAAC,GAAG,CAAC,EACtB,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;IACb,IAAI,KAAK,EAAE,MAAM;QAAE,IAAA,qBAAW,EAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AAC5C,CAAC,CACF,CAAA","sourcesContent":["// tar -x\nimport * as fsm from '@isaacs/fs-minipass'\nimport fs from 'node:fs'\nimport { filesFilter } from './list.js'\nimport { makeCommand } from './make-command.js'\nimport type { TarOptionsFile, TarOptionsSyncFile } from './options.js'\nimport { Unpack, UnpackSync } from './unpack.js'\n\nconst extractFileSync = (opt: TarOptionsSyncFile) => {\n  const u = new UnpackSync(opt)\n  const file = opt.file\n  const stat = fs.statSync(file)\n  // This trades a zero-byte read() syscall for a stat\n  // However, it will usually result in less memory allocation\n  const readSize = opt.maxReadSize || 16 * 1024 * 1024\n  const stream = new fsm.ReadStreamSync(file, {\n    readSize: readSize,\n    size: stat.size,\n  })\n  stream.pipe(u)\n}\n\nconst extractFile = (opt: TarOptionsFile, _?: string[]) => {\n  const u = new Unpack(opt)\n  const readSize = opt.maxReadSize || 16 * 1024 * 1024\n\n  const file = opt.file\n  const p = new Promise<void>((resolve, reject) => {\n    u.on('error', reject)\n    u.on('close', resolve)\n\n    // This trades a zero-byte read() syscall for a stat\n    // However, it will usually result in less memory allocation\n    fs.stat(file, (er, stat) => {\n      if (er) {\n        reject(er)\n      } else {\n        const stream = new fsm.ReadStream(file, {\n          readSize: readSize,\n          size: stat.size,\n        })\n        stream.on('error', reject)\n        stream.pipe(u)\n      }\n    })\n  })\n  return p\n}\n\nexport const extract = makeCommand<Unpack, UnpackSync>(\n  extractFileSync,\n  extractFile,\n  opt => new UnpackSync(opt),\n  opt => new Unpack(opt),\n  (opt, files) => {\n    if (files?.length) filesFilter(opt, files)\n  },\n)\n"]}

.pnpm-store/v11/files/5d/7cc5326b92ed605bcb9676078de848d23952593bb0e71ae676979c2c1606226d5f24e59a48dcd893f46c16f2692f270e4350e9123cc08affef064d35adee44

@@ -0,0 +1,8 @@
+import { TSESLint } from '@typescript-eslint/utils';
+import type { Selector } from './naming-convention-utils';
+export type MessageIds = 'doesNotMatchFormat' | 'doesNotMatchFormatTrimmed' | 'missingAffix' | 'missingUnderscore' | 'satisfyCustom' | 'unexpectedUnderscore';
+export type Options = Selector[];
+declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+    name: string;
+};
+export default _default;

.pnpm-store/v11/files/5d/84073f84d8e99d8af104dabb362688d6fdfe740ec4e0a3c3a23018f9d955abcb88267f034a39e92ce533288967eefe4301ded556eb5b95fbf634f0a9ee233d

@@ -0,0 +1,24 @@
+/**
+ * @license lucide-react v0.469.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+import createLucideIcon from '../createLucideIcon.js';
+
+const BookHeadphones = createLucideIcon("BookHeadphones", [
+  [
+    "path",
+    {
+      d: "M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20",
+      key: "k3hazp"
+    }
+  ],
+  ["path", { d: "M8 12v-2a4 4 0 0 1 8 0v2", key: "1vsqkj" }],
+  ["circle", { cx: "15", cy: "12", r: "1", key: "1tmaij" }],
+  ["circle", { cx: "9", cy: "12", r: "1", key: "1vctgf" }]
+]);
+
+export { BookHeadphones as default };
+//# sourceMappingURL=book-headphones.js.map

.pnpm-store/v11/files/5d/879f316da5d9d3395157a69ae41044a3efbe5c99599e408d8f05c568bd8dd6e78d7df85f07589bd9b0ee8bb15fe9316b3162da6273854b0b6b0e22bc8df2f0

@@ -0,0 +1,192 @@
+/**
+ * @fileoverview The types file for the hfs package.
+ * @author Nicholas C. Zakas
+ */
+
+//------------------------------------------------------------------------------
+// HfsImpl
+//------------------------------------------------------------------------------
+
+export interface HfsImpl {
+
+	/**
+	 * Reads the given file and returns the contents as an Uint8Array.
+	 * @param filePath The file to read.
+	 * @returns The contents of the file as a Uint8Array or undefined if the file is empty.
+	 */
+	bytes?(filePath: string|URL): Promise<Uint8Array|undefined>;
+
+	/**
+	 * Writes the given data to the given file. For text, assumes UTF-8 encoding.
+	 * @param filePath The file to write to.
+	 * @param data The data to write.
+	 * @returns A promise that resolves when the file is written.
+	 * @throws {Error} If the file cannot be written.
+	 */
+	write?(filePath: string|URL, data: Uint8Array): Promise<void>;
+
+	/**
+	 * Appends the given data to the given file. For text, assumes UTF-8 encoding.
+	 * @param filePath The file to append to.
+	 * @param data The data to append.
+	 * @returns A promise that resolves when the file is written.
+	 * @throws {Error} If the file cannot be written.
+	 */
+	append?(filePath: string|URL, data: Uint8Array): Promise<void>;
+
+	/**
+	 * Checks if the given file exists.
+	 * @param filePath The file to check.
+	 * @returns True if the file exists, false if not.
+	 * @throws {Error} If the operation fails with a code other than ENOENT.
+	 */
+	isFile?(filePath: string|URL): Promise<boolean>;
+
+	/**
+	 * Checks if the given directory exists.
+	 * @param dirPath The directory to check.
+	 * @returns True if the directory exists, false if not.
+	 * @throws {Error} If the operation fails with a code other than ENOENT.
+	 */
+	isDirectory?(dirPath: string|URL): Promise<boolean>;
+
+	/**
+	 * Creates the given directory, including any necessary parents.
+	 * @param dirPath The directory to create.
+	 * @returns A promise that resolves when the directory is created.
+	 * @throws {Error} If the directory cannot be created.
+	 */
+	createDirectory?(dirPath: string|URL): Promise<void>;
+
+	/**
+	 * Deletes the given file or empty directory.
+	 * @param fileOrDirPath The file or directory to delete.
+	 * @returns A promise that resolves when the file or directory is deleted,
+	 * 	true if the file or directory was deleted, false if it did not exist.
+	 * @throws {Error} If the file or directory cannot be deleted.
+	 */
+	delete?(fileOrDirPath: string|URL): Promise<boolean>;
+
+	/**
+	 * Deletes the given file or directory recursively.
+	 * @param fileOrDirPath The file or directory to delete.
+	 * @returns A promise that resolves when the file or directory is deleted,
+	 * 	true if the file or directory was deleted, false if it did not exist.
+	 * @throws {Error} If the file or directory cannot be deleted.
+	 */
+	deleteAll?(fileOrDirPath: string|URL): Promise<boolean>;
+
+	/**
+	 * Returns a list of directory entries for the given path.
+	 * @param dirPath The path to the directory to read.
+	 * @returns A promise that resolves with the
+	 *   directory entries.
+	 * @throws {TypeError} If the directory path is not a string.
+	 * @throws {Error} If the directory cannot be read.
+	 */
+	list?(dirPath: string|URL): AsyncIterable<HfsDirectoryEntry>;
+
+	/**
+	 * Returns the size of the given file.
+	 * @param filePath The path to the file to check.
+	 * @returns A promise that resolves with the size of the file in bytes or
+	 * 		undefined if the file does not exist.
+	 * @throws {Error} If the file cannot be read.
+	 */
+	size?(filePath: string|URL): Promise<number|undefined>;
+
+	/**
+	 * Returns the last modified date of the given file or directory.
+	 * @param fileOrDirPath The path to the file or directory to check.
+	 * @returns A promise that resolves with the last modified date of the file or
+	 * 		directory, undefined if the file does not exist.
+	 * @throws {Error} If the file or directory cannot be read.
+	 */
+	lastModified?(fileOrDirPath: string|URL): Promise<Date|undefined>;
+
+	/**
+	 * Copies the file from the source path to the destination path.
+	 * @param source The source file to copy.
+	 * @param destination The destination file to copy to.
+	 * @returns A promise that resolves when the file is copied.
+	 * @throws {Error} If the file cannot be copied.
+	 */
+	copy?(source: string|URL, destination: string|URL): Promise<void>;
+
+	/**
+	 * Copies a file or directory from one location to another.
+	 * @param source The path to the file or directory to copy.
+	 * @param destination The path to copy the file or directory to.
+	 * @returns A promise that resolves when the file or directory is
+	 * copied.
+	 * @throws {Error} If the source file or directory does not exist.
+	 * @throws {Error} If the source cannot be read.
+	 */
+	copyAll?(source: string|URL, destination: string|URL): Promise<void>;
+
+	/**
+	 * Moves a file from the source path to the destination path.
+	 * @param source The location of the file to move.
+	 * @param destination The destination of the file to move.
+	 * @returns A promise that resolves when the file is moved.
+	 * @throws {Error} If the source is a directory.
+	 * @throws {Error} If the file cannot be moved.
+	 */
+	move?(source: string|URL, destination: string|URL): Promise<void>;
+
+	/**
+	 * Moves a file or directory from one location to another.
+	 * @param source The path to the file or directory to move.
+	 * @param destination The path to move the file or directory to.
+	 * @returns A promise that resolves when the file or directory is
+	 * moved.
+	 * @throws {Error} If the source file or directory does not exist.
+	 * @throws {Error} If the source cannot be read.
+	 */
+	moveAll?(source: string|URL, destination: string|URL): Promise<void>;
+}
+
+//------------------------------------------------------------------------------
+// HfsDirectoryEntry
+//------------------------------------------------------------------------------
+
+export interface HfsDirectoryEntry {
+
+	/**
+	 * The name of the file or directory.
+	 */
+	name: string;
+
+	/**
+	 * True if the entry is a directory, false if not.
+	 */
+	isDirectory: boolean;
+
+	/**
+	 * True if the entry is a file, false if not.
+	 */
+	isFile: boolean;
+
+	/**
+	 * True if the entry is a symbolic link, false if not.
+	 */
+	isSymlink: boolean;
+
+}
+
+//------------------------------------------------------------------------------
+// HfsWalkEntry
+//------------------------------------------------------------------------------
+
+export interface HfsWalkEntry extends HfsDirectoryEntry {
+
+	/**
+	 * The path of the entry relative to the directory that was walked.
+	 */
+	path: string;
+
+	/**
+	 * The depth of the entry in the directory tree from the directory that was walked.
+	 */
+	depth: number;
+}

.pnpm-store/v11/files/5d/87ed01fe1a56482613ee0a3b8b2bfd1c7e84225e0b564998fafb6d3e80b533ce1fdcf7466793a08036fcfc4625b1f046138549cac957f12a4dce445601cd9d

@@ -0,0 +1,67 @@
+import Container from './container.js'
+import Node, { NodeProps } from './node.js'
+
+declare namespace Comment {
+  export interface CommentRaws extends Record<string, unknown> {
+    /**
+     * The space symbols before the node.
+     */
+    before?: string
+
+    /**
+     * The space symbols between `/*` and the comment’s text.
+     */
+    left?: string
+
+    /**
+     * The space symbols between the comment’s text.
+     */
+    right?: string
+  }
+
+  export interface CommentProps extends NodeProps {
+    /** Information used to generate byte-to-byte equal node string as it was in the origin input. */
+    raws?: CommentRaws
+    /** Content of the comment. */
+    text: string
+  }
+
+  export { Comment_ as default }
+}
+
+/**
+ * It represents a class that handles
+ * [CSS comments](https://developer.mozilla.org/en-US/docs/Web/CSS/Comments)
+ *
+ * ```js
+ * Once (root, { Comment }) {
+ *   const note = new Comment({ text: 'Note: …' })
+ *   root.append(note)
+ * }
+ * ```
+ *
+ * Remember that CSS comments inside selectors, at-rule parameters,
+ * or declaration values will be stored in the `raws` properties
+ * explained above.
+ */
+declare class Comment_ extends Node {
+  parent: Container | undefined
+  raws: Comment.CommentRaws
+  type: 'comment'
+  /**
+   * The comment's text.
+   */
+  get text(): string
+
+  set text(value: string)
+
+  constructor(defaults?: Comment.CommentProps)
+  assign(overrides: Comment.CommentProps | object): this
+  clone(overrides?: Partial<Comment.CommentProps>): this
+  cloneAfter(overrides?: Partial<Comment.CommentProps>): this
+  cloneBefore(overrides?: Partial<Comment.CommentProps>): this
+}
+
+declare class Comment extends Comment_ {}
+
+export = Comment

.pnpm-store/v11/files/5d/8b4bc9bc116a90a96c227ef6b0df4b4f4e8615bee1ff4c633090a0bbfb1c6b8c97d15b847d9849398a8866e8efa6290c5f3ac17691dd1266e77f74083ba2fe

@@ -0,0 +1 @@
+module.exports={A:{A:{"1":"_SC","16":"FD"},B:{"1":"_J"},C:{"1":"_yL","2":"_UK"},D:{"1":"_Q"},E:{"1":"_R"},F:{"1":"_oB","16":"F"},G:{"1":"_M"},H:{"1":"1D"},I:{"1":"_SB","16":"_m"},J:{"1":"_B"},K:{"1":"_N"},L:{"1":"I"},M:{"1":"YC"},N:{"1":"_A"},O:{"1":"bC"},P:{"1":"_F"},Q:{"1":"JE"},R:{"1":"KE"},S:{"1":"_C"}},B:1,C:"Element.insertAdjacentElement() & Element.insertAdjacentText()",D:true};

.pnpm-store/v11/files/5d/8c3a3632c66d389a4588ff068098185778b360c6c250201036f730da14cefd285520ecb2fbca10ae3454740f28b77a21fa79b0f45b961dbfbcef449b8921d4

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionType = void 0;
+var DefinitionType;
+(function (DefinitionType) {
+    DefinitionType["CatchClause"] = "CatchClause";
+    DefinitionType["ClassName"] = "ClassName";
+    DefinitionType["FunctionName"] = "FunctionName";
+    DefinitionType["ImplicitGlobalVariable"] = "ImplicitGlobalVariable";
+    DefinitionType["ImportBinding"] = "ImportBinding";
+    DefinitionType["Parameter"] = "Parameter";
+    DefinitionType["TSEnumName"] = "TSEnumName";
+    DefinitionType["TSEnumMember"] = "TSEnumMemberName";
+    DefinitionType["TSModuleName"] = "TSModuleName";
+    DefinitionType["Type"] = "Type";
+    DefinitionType["Variable"] = "Variable";
+})(DefinitionType || (exports.DefinitionType = DefinitionType = {}));

.pnpm-store/v11/files/5d/99f66cb8c5b8a9e586587d07b95fc87e9f1e6ee4e62f5b75c82ed9cff32755c084dd1e8ea66f4a0c770d87c6c888626dd59640bbb7d174566d4e3782d22a4f

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview A rule to disallow modifying variables that are declared using `const`
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const CONSTANT_BINDINGS = new Set(["const", "using", "await using"]);
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow reassigning `const`, `using`, and `await using` variables",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-const-assign",
+		},
+
+		schema: [],
+
+		messages: {
+			const: "'{{name}}' is constant.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Finds and reports references that are non initializer and writable.
+		 * @param {Variable} variable A variable to check.
+		 * @returns {void}
+		 */
+		function checkVariable(variable) {
+			astUtils
+				.getModifyingReferences(variable.references)
+				.forEach(reference => {
+					context.report({
+						node: reference.identifier,
+						messageId: "const",
+						data: { name: reference.identifier.name },
+					});
+				});
+		}
+
+		return {
+			VariableDeclaration(node) {
+				if (CONSTANT_BINDINGS.has(node.kind)) {
+					sourceCode
+						.getDeclaredVariables(node)
+						.forEach(checkVariable);
+				}
+			},
+		};
+	},
+};

.pnpm-store/v11/files/5d/9da3641e7bc5e2ceec2c1c7a02af37be9ad9865bf5c9ef4b0992dcd2b10fed0fa6a9db170093c203427875a37e4596533953954af9204a24424966ef2e235d

@@ -0,0 +1,5 @@
+const require_ajvProvider = require('../ajvProvider-1b6pVpkg.cjs');
+
+exports.Ajv = require_ajvProvider.Ajv;
+exports.AjvJsonSchemaValidator = require_ajvProvider.AjvJsonSchemaValidator;
+exports.addFormats = require_ajvProvider.addFormats;

.pnpm-store/v11/files/5d/a1f49c40da8bcaf243486c3594770c77c437c8ffab147ce3a3cafcc7a4dc6ceb8b690737f1d4246350153f7cffae8896ef1e948baf1b4928f7acd58c9e8a41

@@ -0,0 +1,55 @@
+{{# def.definitions }}
+{{# def.errors }}
+{{# def.setupKeyword }}
+{{# def.setupNextLevel }}
+
+
+{{
+  var $idx = 'i' + $lvl
+    , $dataNxt = $it.dataLevel = it.dataLevel + 1
+    , $nextData = 'data' + $dataNxt
+    , $currentBaseId = it.baseId
+    , $nonEmptySchema = {{# def.nonEmptySchema:$schema }};
+}}
+
+var {{=$errs}} = errors;
+var {{=$valid}};
+
+{{? $nonEmptySchema }}
+  {{# def.setCompositeRule }}
+
+  {{
+    $it.schema = $schema;
+    $it.schemaPath = $schemaPath;
+    $it.errSchemaPath = $errSchemaPath;
+  }}
+
+  var {{=$nextValid}} = false;
+
+  for (var {{=$idx}} = 0; {{=$idx}} < {{=$data}}.length; {{=$idx}}++) {
+    {{
+      $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);
+      var $passData = $data + '[' + $idx + ']';
+      $it.dataPathArr[$dataNxt] = $idx;
+    }}
+
+    {{# def.generateSubschemaCode }}
+    {{# def.optimizeValidate }}
+
+    if ({{=$nextValid}}) break;
+  }
+
+  {{# def.resetCompositeRule }}
+  {{= $closingBraces }}
+
+  if (!{{=$nextValid}}) {
+{{??}}
+  if ({{=$data}}.length == 0) {
+{{?}}
+
+    {{# def.error:'contains' }}
+  } else {
+    {{? $nonEmptySchema }}
+      {{# def.resetErrors }}
+    {{?}}
+  {{? it.opts.allErrors }} } {{?}}

.pnpm-store/v11/files/5d/a43baaf848a85721939c51243cb28a0591cea341e7e2d154b7301b837aa729b176d0635de84f30aac548e0ca8fc9c89ade58b7d086bfdc8f175b4f87fe531d

@@ -0,0 +1,17 @@
+/**
+ * @license lucide-react v0.469.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+import createLucideIcon from '../createLucideIcon.js';
+
+const BedSingle = createLucideIcon("BedSingle", [
+  ["path", { d: "M3 20v-8a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v8", key: "1wm6mi" }],
+  ["path", { d: "M5 10V6a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v4", key: "4k93s5" }],
+  ["path", { d: "M3 18h18", key: "1h113x" }]
+]);
+
+export { BedSingle as default };
+//# sourceMappingURL=bed-single.js.map

.pnpm-store/v11/files/5d/a4a4de4e4128daa1901b05657a73089eeaa2aa56b64eb0a351ab1a55ac3780e37342ff8eabc3cccfddab232483543c40851f233c313ead81ad01a99e621f0e

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hooks = void 0;
+const hooks = exports.hooks = [function (self, parent) {
+  const removeParent = self.key === "test" && (parent.isWhile() || parent.isSwitchCase()) || self.key === "declaration" && parent.isExportDeclaration() || self.key === "body" && parent.isLabeledStatement() || self.listKey === "declarations" && parent.isVariableDeclaration() && parent.node.declarations.length === 1 || self.key === "expression" && parent.isExpressionStatement();
+  if (removeParent) {
+    parent.remove();
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
+    parent.replaceWith(parent.node.expressions[0]);
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isBinary()) {
+    if (self.key === "left") {
+      parent.replaceWith(parent.node.right);
+    } else {
+      parent.replaceWith(parent.node.left);
+    }
+    return true;
+  }
+}, function (self, parent) {
+  if (parent.isIfStatement() && self.key === "consequent" || self.key === "body" && (parent.isLoop() || parent.isArrowFunctionExpression())) {
+    self.replaceWith({
+      type: "BlockStatement",
+      directives: [],
+      body: []
+    });
+    return true;
+  }
+}];
+
+//# sourceMappingURL=removal-hooks.js.map

.pnpm-store/v11/files/5d/a983844589c8c00b78a92d2c9badfef1289bad719d096ee5721f8e09820223f0018a7d591a0794af85b898def5c754fa37b852427ca87f3d4328dc5ebef4c6

@@ -0,0 +1,65 @@
+{
+  "name": "@eslint/config-array",
+  "version": "0.23.5",
+  "description": "General purpose glob-based configuration matching.",
+  "author": "Nicholas C. Zakas",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eslint/rewrite.git",
+    "directory": "packages/config-array"
+  },
+  "bugs": {
+    "url": "https://github.com/eslint/rewrite/issues"
+  },
+  "homepage": "https://github.com/eslint/rewrite/tree/main/packages/config-array#readme",
+  "scripts": {
+    "build:dedupe-types": "node ../../tools/dedupe-types.js dist/cjs/index.cjs dist/esm/index.js",
+    "build:cts": "node ../../tools/build-cts.js dist/esm/index.d.ts dist/cjs/index.d.cts",
+    "build:std__path": "rollup -c rollup.std__path-config.js && node fix-std__path-imports",
+    "build": "rollup -c && npm run build:dedupe-types && tsc -p tsconfig.esm.json && npm run build:cts && npm run build:std__path",
+    "lint:types": "attw --pack",
+    "pretest": "npm run build",
+    "test": "npm run test:types && npm run test:unit",
+    "test:coverage": "npm run build && c8 npm run test:unit",
+    "test:jsr": "npx -y jsr@latest publish --dry-run",
+    "test:types": "tsc -p tests/types/tsconfig.json",
+    "test:unit": "mocha \"tests/**/*.test.js\""
+  },
+  "keywords": [
+    "configuration",
+    "configarray",
+    "config file"
+  ],
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@eslint/object-schema": "^3.0.5",
+    "debug": "^4.3.1",
+    "minimatch": "^10.2.4"
+  },
+  "devDependencies": {
+    "@jsr/std__path": "^1.0.4",
+    "rollup-plugin-copy": "^3.5.0"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  }
+}

.pnpm-store/v11/files/5d/ac386f5fabe22d78ecebb6e169b61589fb96cfe112d109dc2cb83c9575808a3db86421f8d1017d877359c888ab8a7a2ee6bceccc31b02c99547f8fc1c27065

@@ -0,0 +1 @@
+{"version":3,"file":"lamp-wall-down.js","sources":["../../../src/icons/lamp-wall-down.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name LampWallDown\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTEgMTNoNmwzIDdIOGwzLTdaIiAvPgogIDxwYXRoIGQ9Ik0xNCAxM1Y4YTIgMiAwIDAgMC0yLTJIOCIgLz4KICA8cGF0aCBkPSJNNCA5aDJhMiAyIDAgMCAwIDItMlY1YTIgMiAwIDAgMC0yLTJINHY2WiIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/lamp-wall-down\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst LampWallDown = createLucideIcon('LampWallDown', [\n  ['path', { d: 'M11 13h6l3 7H8l3-7Z', key: '9n3qlo' }],\n  ['path', { d: 'M14 13V8a2 2 0 0 0-2-2H8', key: '1hu4hb' }],\n  ['path', { d: 'M4 9h2a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H4v6Z', key: 's053bc' }],\n]);\n\nexport default LampWallDown;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAe,iBAAiB,cAAgB,CAAA,CAAA,CAAA;AAAA,CAAA,CACpD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAuB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACpD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA4B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACzD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA6C,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC5E,CAAC,CAAA,CAAA;;"}

.pnpm-store/v11/files/5d/ad1a2d95376168f3b72afb8cbb5b3af8642b30cd532b56efcab934eb11ed5c47009d957e70ad397b0f2446dedd4ab8b67b328259f4d540576250ee738bd268

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssignee = isAssignee;
+const utils_1 = require("@typescript-eslint/utils");
+function isAssignee(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return false;
+    }
+    // a[i] = 1, a[i] += 1, etc.
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        parent.left === node) {
+        return true;
+    }
+    // delete a[i]
+    if (parent.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === 'delete' &&
+        parent.argument === node) {
+        return true;
+    }
+    // a[i]++, --a[i], etc.
+    if (parent.type === utils_1.AST_NODE_TYPES.UpdateExpression &&
+        parent.argument === node) {
+        return true;
+    }
+    // [a[i]] = [0]
+    if (parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        return true;
+    }
+    // [...a[i]] = [0]
+    if (parent.type === utils_1.AST_NODE_TYPES.RestElement) {
+        return true;
+    }
+    // ({ foo: a[i] }) = { foo: 0 }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+        parent.value === node &&
+        parent.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+        isAssignee(parent.parent)) {
+        return true;
+    }
+    // (a[i] as number)++, [...a[i]!] = [0], etc.
+    if ((parent.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        parent.type === utils_1.AST_NODE_TYPES.TSTypeAssertion ||
+        parent.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) &&
+        isAssignee(parent)) {
+        return true;
+    }
+    return false;
+}

.pnpm-store/v11/files/5d/aeb43747673bad193af91f9ea5cdde6ff537e8ad0c2bb90fe8bcb175a768297d40b3c7700377423c23bd45c5675aaaa1cb1f2ed9c86aedcfbbeaa840cf4120

@@ -0,0 +1,79 @@
+{{# def.definitions }}
+{{# def.errors }}
+{{# def.missing }}
+{{# def.setupKeyword }}
+{{# def.setupNextLevel }}
+
+
+{{## def.propertyInData:
+  {{=$data}}{{= it.util.getProperty($property) }} !== undefined
+  {{? $ownProperties }}
+    && Object.prototype.hasOwnProperty.call({{=$data}}, '{{=it.util.escapeQuotes($property)}}')
+  {{?}}
+#}}
+
+
+{{
+  var $schemaDeps = {}
+    , $propertyDeps = {}
+    , $ownProperties = it.opts.ownProperties;
+
+  for ($property in $schema) {
+    if ($property == '__proto__') continue;
+    var $sch = $schema[$property];
+    var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;
+    $deps[$property] = $sch;
+  }
+}}
+
+var {{=$errs}} = errors;
+
+{{ var $currentErrorPath = it.errorPath; }}
+
+var missing{{=$lvl}};
+{{ for (var $property in $propertyDeps) { }}
+  {{ $deps = $propertyDeps[$property]; }}
+  {{? $deps.length }}
+    if ({{# def.propertyInData }}
+      {{? $breakOnError }}
+          && ({{# def.checkMissingProperty:$deps }})) {
+          {{# def.errorMissingProperty:'dependencies' }}
+      {{??}}
+        ) {
+          {{~ $deps:$propertyKey }}
+            {{# def.allErrorsMissingProperty:'dependencies' }}
+          {{~}}
+      {{?}}
+    } {{# def.elseIfValid }}
+  {{?}}
+{{ } }}
+
+{{
+  it.errorPath = $currentErrorPath;
+  var $currentBaseId = $it.baseId;
+}}
+
+
+{{ for (var $property in $schemaDeps) { }}
+  {{ var $sch = $schemaDeps[$property]; }}
+  {{? {{# def.nonEmptySchema:$sch }} }}
+    {{=$nextValid}} = true;
+
+    if ({{# def.propertyInData }}) {
+      {{ 
+        $it.schema = $sch;
+        $it.schemaPath = $schemaPath + it.util.getProperty($property);
+        $it.errSchemaPath = $errSchemaPath + '/' + it.util.escapeFragment($property);
+      }}
+
+      {{# def.insertSubschemaCode }}
+    }
+
+    {{# def.ifResultValid }}
+  {{?}}
+{{ } }}
+
+{{? $breakOnError }} 
+  {{= $closingBraces }}
+  if ({{=$errs}} == errors) {
+{{?}}

.pnpm-store/v11/files/5d/b128cb43fa9f6dbb8ed80cd07649284b270749c60cf87efeaf57ab4a2a6cea0d44af00c3f95ca86b7873043d4f71df0841427aa901ff4c9303e8357c92f47a

@@ -0,0 +1 @@
+{"version":3,"file":"bell-electric.js","sources":["../../../src/icons/bell-electric.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name BellElectric\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTguOCA0QTYuMyA4LjcgMCAwIDEgMjAgOSIgLz4KICA8cGF0aCBkPSJNOSA5aC4wMSIgLz4KICA8Y2lyY2xlIGN4PSI5IiBjeT0iOSIgcj0iNyIgLz4KICA8cmVjdCB3aWR0aD0iMTAiIGhlaWdodD0iNiIgeD0iNCIgeT0iMTYiIHJ4PSIyIiAvPgogIDxwYXRoIGQ9Ik0xNCAxOWMzIDAgNC42LTEuNiA0LjYtMS42IiAvPgogIDxjaXJjbGUgY3g9IjIwIiBjeT0iMTYiIHI9IjIiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/bell-electric\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst BellElectric = createLucideIcon('BellElectric', [\n  ['path', { d: 'M18.8 4A6.3 8.7 0 0 1 20 9', key: 'xve1fh' }],\n  ['path', { d: 'M9 9h.01', key: '1q5me6' }],\n  ['circle', { cx: '9', cy: '9', r: '7', key: 'p2h5vp' }],\n  ['rect', { width: '10', height: '6', x: '4', y: '16', rx: '2', key: '17f3te' }],\n  ['path', { d: 'M14 19c3 0 4.6-1.6 4.6-1.6', key: 'n7odp6' }],\n  ['circle', { cx: '20', cy: '16', r: '2', key: '1v9bxh' }],\n]);\n\nexport default BellElectric;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAe,iBAAiB,cAAgB,CAAA,CAAA,CAAA;AAAA,CAAA,CACpD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA8B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC3D,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAY,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CACzC,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,EAAK,CAAI,CAAA,CAAA,CAAA,GAAA,CAAK,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA,CAAA;AAAA,CAAA,CACtD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAO,MAAM,CAAQ,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,CAAG,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAG,CAAM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAI,CAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC9E,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA8B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAC3D,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAM,CAAI,CAAA,CAAA,CAAA,IAAA,CAAM,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA;AAC1D,CAAC,CAAA,CAAA;;"}

.pnpm-store/v11/files/5d/b3f7c71de31ca75dd5116e898fe83734c87af0d4b2d1e7690ff23db8519b378c8804d5d23060f84a87de14ba36e4a5d8c23397d91a9eb309cc57be87d0c58b

@@ -0,0 +1,25 @@
+{
+  "name": "hermes-parser",
+  "version": "0.25.1",
+  "description": "A JavaScript parser built from the Hermes engine",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:facebook/hermes.git"
+  },
+  "dependencies": {
+    "hermes-estree": "0.25.1"
+  },
+  "devDependencies": {
+    "@babel/parser": "7.7.4",
+    "@babel/generator": "7.7.4",
+    "@babel/types": "7.7.4",
+    "espree": "9.3.2"
+  },
+  "files": [
+    "dist",
+    "LICENCE",
+    "README.md"
+  ]
+}

.pnpm-store/v11/files/5d/b4139d87e1a700c82dcaf3b408ef7c489a4acbc55e8cf3c4f3d7aa67e48b63c5562573a402d0877eb2c44e8c6b4103a71ba25f3d3dc2cdba0750c589159dea

@@ -0,0 +1 @@
+{"version":3,"file":"HeadContent.dev.js","names":[],"sources":["../../src/HeadContent.dev.tsx"],"sourcesContent":["'use client'\n\nimport * as React from 'react'\nimport { Asset } from './Asset'\nimport { useRouter } from './useRouter'\nimport { useHydrated } from './ClientOnly'\nimport { useTags } from './headContentUtils'\nimport type { HeadContentProps } from './HeadContent'\n\nconst DEV_STYLES_ATTR = 'data-tanstack-router-dev-styles'\n\n/**\n * Render route-managed head tags (title, meta, links, styles, head scripts).\n * Place inside the document head of your app shell.\n *\n * Development version: filters out dev styles link after hydration and\n * includes a fallback cleanup effect for hydration mismatch cases.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/document-head-management\n */\nexport function HeadContent(props: HeadContentProps) {\n  const tags = useTags(props.assetCrossOrigin)\n  const router = useRouter()\n  const nonce = router.options.ssr?.nonce\n  const hydrated = useHydrated()\n\n  // Fallback cleanup for hydration mismatch cases\n  // Runs when hydration completes to remove any orphaned dev styles links from DOM\n  React.useEffect(() => {\n    if (hydrated) {\n      document\n        .querySelectorAll(`link[${DEV_STYLES_ATTR}]`)\n        .forEach((el) => el.remove())\n    }\n  }, [hydrated])\n\n  // Filter out dev styles after hydration\n  const filteredTags = hydrated\n    ? tags.filter((tag) => !tag.attrs?.[DEV_STYLES_ATTR])\n    : tags\n\n  return (\n    <>\n      {filteredTags.map((tag) => (\n        <Asset {...tag} key={`tsr-meta-${JSON.stringify(tag)}`} nonce={nonce} />\n      ))}\n    </>\n  )\n}\n"],"mappings":";;;;;;;;;AASA,IAAM,kBAAkB;;;;;;;;;;AAWxB,SAAgB,YAAY,OAAyB;CACnD,MAAM,OAAO,QAAQ,MAAM,iBAAiB;CAE5C,MAAM,QADS,WAAW,CACL,QAAQ,KAAK;CAClC,MAAM,WAAW,aAAa;AAI9B,SAAM,gBAAgB;AACpB,MAAI,SACF,UACG,iBAAiB,QAAQ,gBAAgB,GAAG,CAC5C,SAAS,OAAO,GAAG,QAAQ,CAAC;IAEhC,CAAC,SAAS,CAAC;AAOd,QACE,oBAAA,UAAA,EAAA,WALmB,WACjB,KAAK,QAAQ,QAAQ,CAAC,IAAI,QAAQ,iBAAiB,GACnD,MAIc,KAAK,QACjB,8BAAC,OAAD;EAAO,GAAI;EAAK,KAAK,YAAY,KAAK,UAAU,IAAI;EAAW;EAAS,CAAA,CACxE,EACD,CAAA"}

.pnpm-store/v11/files/5d/b6353c3eccac1a6eafd0dff8eda5b3394efcb1e674169ced6e4f43625565aa17f87db5a9481301a3357ddbb79b45fe138c20fea5c0b6e00e97339d083e2310

@@ -0,0 +1,6 @@
+import type { ProjectServiceAndMetadata } from '@typescript-eslint/project-service';
+import type { ASTAndDefiniteProgram, ASTAndNoProgram, ASTAndProgram } from './create-program/shared';
+import type { MutableParseSettings } from './parseSettings';
+export declare function useProgramFromProjectService(serviceAndSettings: ProjectServiceAndMetadata, parseSettings: Readonly<MutableParseSettings>, hasFullTypeInformation: boolean, defaultProjectMatchedFiles: Set<string>): ASTAndProgram | undefined;
+export declare function useProgramFromProjectService(serviceAndSettings: ProjectServiceAndMetadata, parseSettings: Readonly<MutableParseSettings>, hasFullTypeInformation: true, defaultProjectMatchedFiles: Set<string>): ASTAndDefiniteProgram | undefined;
+export declare function useProgramFromProjectService(serviceAndSettings: ProjectServiceAndMetadata, parseSettings: Readonly<MutableParseSettings>, hasFullTypeInformation: false, defaultProjectMatchedFiles: Set<string>): ASTAndNoProgram | undefined;

.pnpm-store/v11/files/5d/b8305cdc1e37c940b4f89452faae459f4c9a2052064d7aca43a366ee1aaad18479857e988a6b25e68420215e86b98b9647c5673eb03d915521e0de4ccddf66

@@ -0,0 +1,19 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+module.exports.AsyncParallelBailHook = require("./AsyncParallelBailHook");
+module.exports.AsyncParallelHook = require("./AsyncParallelHook");
+module.exports.AsyncSeriesBailHook = require("./AsyncSeriesBailHook");
+module.exports.AsyncSeriesHook = require("./AsyncSeriesHook");
+module.exports.AsyncSeriesLoopHook = require("./AsyncSeriesLoopHook");
+module.exports.AsyncSeriesWaterfallHook = require("./AsyncSeriesWaterfallHook");
+module.exports.HookMap = require("./HookMap");
+module.exports.MultiHook = require("./MultiHook");
+module.exports.SyncBailHook = require("./SyncBailHook");
+module.exports.SyncHook = require("./SyncHook");
+module.exports.SyncLoopHook = require("./SyncLoopHook");
+module.exports.SyncWaterfallHook = require("./SyncWaterfallHook");
+module.exports.__esModule = true;

.pnpm-store/v11/files/5d/c008dd07fe8c6f199ad02284419a45857e74f0cc9f57f4e62ac77753859f983f15184f7c3202d27fb3d687a46484fb882c3d9397072126d562caf496dd8962

@@ -0,0 +1,221 @@
+/**
+ * @fileoverview Rule to enforce a particular function style
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
+		type: "suggestion",
+
+		defaultOptions: [
+			"expression",
+			{
+				allowArrowFunctions: false,
+				allowTypeAnnotation: false,
+				overrides: {},
+			},
+		],
+
+		docs: {
+			description:
+				"Enforce the consistent use of either `function` declarations or expressions assigned to variables",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/func-style",
+		},
+
+		schema: [
+			{
+				enum: ["declaration", "expression"],
+			},
+			{
+				type: "object",
+				properties: {
+					allowArrowFunctions: {
+						type: "boolean",
+					},
+					allowTypeAnnotation: {
+						type: "boolean",
+					},
+					overrides: {
+						type: "object",
+						properties: {
+							namedExports: {
+								enum: ["declaration", "expression", "ignore"],
+							},
+						},
+						additionalProperties: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			expression: "Expected a function expression.",
+			declaration: "Expected a function declaration.",
+		},
+	},
+
+	create(context) {
+		const [style, { allowArrowFunctions, allowTypeAnnotation, overrides }] =
+			context.options;
+		const enforceDeclarations = style === "declaration";
+		const { namedExports: exportFunctionStyle } = overrides;
+		const stack = [];
+
+		/**
+		 * Checks if a function declaration is part of an overloaded function
+		 * @param {ASTNode} node The function declaration node to check
+		 * @returns {boolean} True if the function is overloaded
+		 */
+		function isOverloadedFunction(node) {
+			const functionName = node.id.name;
+
+			if (node.parent.type === "ExportNamedDeclaration") {
+				return node.parent.parent.body.some(
+					member =>
+						member.type === "ExportNamedDeclaration" &&
+						member.declaration?.type === "TSDeclareFunction" &&
+						member.declaration.id.name === functionName,
+				);
+			}
+
+			if (node.parent.type === "SwitchCase") {
+				return node.parent.parent.cases.some(switchCase =>
+					switchCase.consequent.some(
+						member =>
+							member.type === "TSDeclareFunction" &&
+							member.id.name === functionName,
+					),
+				);
+			}
+
+			return (
+				Array.isArray(node.parent.body) &&
+				node.parent.body.some(
+					member =>
+						member.type === "TSDeclareFunction" &&
+						member.id.name === functionName,
+				)
+			);
+		}
+
+		const nodesToCheck = {
+			FunctionDeclaration(node) {
+				stack.push(false);
+
+				if (
+					!enforceDeclarations &&
+					node.parent.type !== "ExportDefaultDeclaration" &&
+					(typeof exportFunctionStyle === "undefined" ||
+						node.parent.type !== "ExportNamedDeclaration") &&
+					!isOverloadedFunction(node)
+				) {
+					context.report({ node, messageId: "expression" });
+				}
+
+				if (
+					node.parent.type === "ExportNamedDeclaration" &&
+					exportFunctionStyle === "expression" &&
+					!isOverloadedFunction(node)
+				) {
+					context.report({ node, messageId: "expression" });
+				}
+			},
+			"FunctionDeclaration:exit"() {
+				stack.pop();
+			},
+
+			FunctionExpression(node) {
+				stack.push(false);
+
+				if (
+					enforceDeclarations &&
+					node.parent.type === "VariableDeclarator" &&
+					(typeof exportFunctionStyle === "undefined" ||
+						node.parent.parent.parent.type !==
+							"ExportNamedDeclaration") &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
+				) {
+					context.report({
+						node: node.parent,
+						messageId: "declaration",
+					});
+				}
+
+				if (
+					node.parent.type === "VariableDeclarator" &&
+					node.parent.parent.parent.type ===
+						"ExportNamedDeclaration" &&
+					exportFunctionStyle === "declaration" &&
+					!(allowTypeAnnotation && node.parent.id.typeAnnotation)
+				) {
+					context.report({
+						node: node.parent,
+						messageId: "declaration",
+					});
+				}
+			},
+			"FunctionExpression:exit"() {
+				stack.pop();
+			},
+
+			"ThisExpression, Super"() {
+				if (stack.length > 0) {
+					stack[stack.length - 1] = true;
+				}
+			},
+		};
+
+		if (!allowArrowFunctions) {
+			nodesToCheck.ArrowFunctionExpression = function () {
+				stack.push(false);
+			};
+
+			nodesToCheck["ArrowFunctionExpression:exit"] = function (node) {
+				const hasThisOrSuperExpr = stack.pop();
+
+				if (
+					!hasThisOrSuperExpr &&
+					node.parent.type === "VariableDeclarator"
+				) {
+					if (
+						enforceDeclarations &&
+						(typeof exportFunctionStyle === "undefined" ||
+							node.parent.parent.parent.type !==
+								"ExportNamedDeclaration") &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
+					) {
+						context.report({
+							node: node.parent,
+							messageId: "declaration",
+						});
+					}
+
+					if (
+						node.parent.parent.parent.type ===
+							"ExportNamedDeclaration" &&
+						exportFunctionStyle === "declaration" &&
+						!(allowTypeAnnotation && node.parent.id.typeAnnotation)
+					) {
+						context.report({
+							node: node.parent,
+							messageId: "declaration",
+						});
+					}
+				}
+			};
+		}
+
+		return nodesToCheck;
+	},
+};

.pnpm-store/v11/files/5d/c369ad53230e385b5a61f739335957dd5487db03682b3ca196b727b839c0c507b1d309444366bf85d0ffccaa3254d4c4aa29bfcba2ced10b44423b730f010e

@@ -0,0 +1,38 @@
+// Note: named reexports are used instead of `export *` because
+// TypeScript itself doesn't resolve the `export *` when checking
+// if a particular helper exists.
+export {
+  __extends,
+  __assign,
+  __rest,
+  __decorate,
+  __param,
+  __esDecorate,
+  __runInitializers,
+  __propKey,
+  __setFunctionName,
+  __metadata,
+  __awaiter,
+  __generator,
+  __exportStar,
+  __values,
+  __read,
+  __spread,
+  __spreadArrays,
+  __spreadArray,
+  __await,
+  __asyncGenerator,
+  __asyncDelegator,
+  __asyncValues,
+  __makeTemplateObject,
+  __importStar,
+  __importDefault,
+  __classPrivateFieldGet,
+  __classPrivateFieldSet,
+  __classPrivateFieldIn,
+  __createBinding,
+  __addDisposableResource,
+  __disposeResources,
+  __rewriteRelativeImportExtension,
+} from '../tslib.js';
+export * as default from '../tslib.js';

.pnpm-store/v11/files/5d/c57eb7fccc2d582b02b581632202ecc1404ce7154be10e379268de49580f2d72b1220089c12706c41c91b1d989cf634aeaad4e6cac6e2b5c36122506e115d1

@@ -0,0 +1,6 @@
+"use strict";
+// THIS CODE WAS AUTOMATICALLY GENERATED
+// DO NOT EDIT THIS CODE BY HAND
+// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
+// npx nx generate-lib repo
+Object.defineProperty(exports, "__esModule", { value: true });

.pnpm-store/v11/files/5d/c845fadbdae2080cc8c520385d4d00380e9587a369723e5aaf950f9bbe0a8d122f1bfc0cc6db75c657a1e46516dec6f3433c2fa8e2d36330e4f1ac53af5ec4

@@ -0,0 +1 @@
+module.exports={A:{A:{"1":"_V","2":"_b"},B:{"1":"_J"},C:{"1":"_fD","16":"GD"},D:{"1":"_Q"},E:{"1":"_DB","16":"_e"},F:{"1":"_yF","2":"_0D","16":"C"},G:{"1":"_t","16":"_d"},H:{"2":"1D"},I:{"1":"_SB","16":"_m"},J:{"1":"_B"},K:{"1":"_ZB","2":"_gB","16":"C"},L:{"1":"I"},M:{"130":"YC"},N:{"130":"_A"},O:{"1":"bC"},P:{"1":"_F"},Q:{"1":"JE"},R:{"1":"KE"},S:{"1":"_C"}},B:7,C:"KeyboardEvent.charCode",D:true};

.pnpm-store/v11/files/5d/c9dfa76467da1cfc6714c06fffff47d6cc7f5eca0338384b4a11ea310310597d9c123c5fba6ee324e9d6f4f13b00738ac191b5e16caec730811138bf1e62e8

@@ -0,0 +1 @@
+export * from './dist/error.js'

.pnpm-store/v11/files/5d/d0621f4e56a8261b2d25b8fb8fe3f557e44b8e7f348cf44d155ca287f705e2f2d69d312ca1b2644c06e3f735c0464844dd43e0b48a08646c85b17327f0b94f

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Wombosvideo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.pnpm-store/v11/files/5d/d2019b69bbea1c9baf82a29fe8a2ec115fd1c406dfdd94536f9c8023047e10b157efb8da590f74e29849f800c2e287a1036c1fd327887fcf4addc72e3a5396

@@ -0,0 +1,841 @@
+export default `flf2a$ 8 7 16 0 24 0 64 0
+Author : LG Beard
+Date   : 2005/5/7 18:52:57
+Version: 1.0
+---------------------------------------------------------------
+  ___      ___   _______   _______   ___      __   _____  ___
+ ("  \\    /"  | /"      | /"      \\ |"  |    |" \\ (\\"   \\|"  \\
+  \\   \\  //   |(: ______)|:        |||  |    ||  ||.\\\\   \\    |
+  /\\\\  \\/.    | \\/      ||_____/   )|:  |    |:  ||: \\.   \\\\  |
+ |: \\.        | // _____) //      /  \\  |___ |.  ||.  \\    \\. |
+ |.  \\    /:  |(:       ||:  __   \\ ( \\_|:  \\|   ||    \\    \\ |
+ |___|\\__/|___| \\_______)|__|  \\___) \\_______)\\___)\\___|\\____\\)
+
+Font built from a sig dated 17 Feb 1995
+---------------------------------------------------------------
+This font has been created using JavE's FIGlet font export assistant.
+Have a look at: http://www.jave.de
+
+Permission is hereby given to modify this font, as long as the
+modifier's name is placed on a comment line.
+
+---
+
+Font modified June 17, 2007 by patorjk 
+This was to widen the space character.
+$  $#
+$  $#
+$  $#
+$  $#
+$  $#
+$  $#
+$  $#
+$  $##
+    ___  #
+   |"  | #
+   ||  | #
+   |:  | #
+  _|  /  #
+ / |_/ ) #
+(_____/  #
+         ##
+  ____ _____  #
+ ))_ ")))_ ") #
+(____((____(  #
+              #
+              #
+              #
+              #
+              ##
+##
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+$#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+  ____  ___   #
+ ))_ ")/"  |  #
+(____(/  //   #
+     /'  /    #
+    //  /____ #
+   /  //))_ ")#
+  |___/(____( #
+              ##
+&#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+  ____  #
+ ))_ ") #
+(____(  #
+        #
+        #
+        #
+        #
+        ##
+    ____  #
+   /   ") #
+  /. __/  #
+ // /     #
+(: (___   #
+ \\     )  #
+  \\"__/   #
+          ##
+  ____    #
+ (  " \\   #
+  \\__. \\  #
+     ) :) #
+  __/ //  #
+ /"   /   #
+(____/    #
+          ##
+*#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+  _______  #
+ ))_    ") #
+(_______(  #
+ ________  #
+ ))_    ") #
+(_______(  #
+           #
+           ##
+         #
+         #
+         #
+         #
+  _____  #
+ //   ") #
+(_____/  #
+         ##
+-#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+         #
+         #
+         #
+         #
+  _____  #
+ ))_  ") #
+(_____(  #
+         ##
+      ___  #
+     /"  | #
+    /  //  #
+   /'  /   #
+  //  /    #
+ /  //     #
+|___/      #
+           ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    ) :) #
+(: (____/ //  #
+ \\        /   #
+  \\"_____/    #
+              ##
+   ____    #
+  /  " \\   #
+ /__|| |   #
+    |: |   #
+   _\\  |   #
+  /" \\_|\\  #
+ (_______) #
+           ##
+  _______    #
+ /"     "\\   #
+(__/\\    :)  #
+    / ___/   #
+   // \\___   #
+  (:  /  "\\  #
+   \\_______) #
+             ##
+  _______  #
+ /" __   ) #
+(__/ _) ./ #
+    /  //  #
+ __ \\_ \\\\  #
+(: \\__) :\\ #
+ \\_______) #
+           ##
+ ___  ___    #
+(: "||_  |   #
+|  (__) :|   #
+ \\____  ||   #
+     _\\ '|   #
+    /" \\_|\\  #
+   (_______) #
+             ##
+   ________  #
+  /"      ") #
+ (:   //\\_/  #
+  \\___ \\     #
+  __ | \\\\    #
+ /" \\/  :)   #
+(_______/    #
+             ##
+    ___     #
+   /. ")    #
+  /:  /     #
+ //  /___   #
+(   / _  \\  #
+|:   /_) :) #
+ \\_______/  #
+            ##
+ _________  #
+("       "\\ #
+ \\___/   :/ #
+    /   //  #
+  __\\  ./   #
+ (:  \\_/ \\  #
+  \\_______) #
+            ##
+  _______   #
+ /"  _  \\\\  #
+|:  _ /  :| #
+ \\___/___/  #
+ //  /_ \\\\  #
+|:  /_   :| #
+ \\_______/  #
+            ##
+  _______    #
+ /" _   "\\   #
+(: (_/  :|   #
+ \\____/ |)   #
+    _\\  '|   #
+   /" \\__|\\  #
+  (________) #
+             ##
+  ____  #
+ ))_ ") #
+(____(  #
+ _____  #
+ ))_ ") #
+(____(  #
+        #
+        ##
+   ____  #
+  ))_ ") #
+ (____(  #
+  ____   #
+ //  ")  #
+(____/   #
+         #
+         ##
+            #
+   _______  #
+ _/"     ") #
+//   /___/  #
+\\\\   \\   \\  #
+  \\_______) #
+            #
+            ##
+=#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+            #
+ _______    #
+("     "\\_  #
+ \\___\\   \\\\ #
+ /   /   // #
+(_______/   #
+            #
+            ##
+ ________   #
+("      "\\  #
+ \\___/   :) #
+   /  ___/  #
+  //  \\     #
+ ('___/     #
+  (___)     #
+            ##
+@#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+      __      #
+     /""\\     #
+    /    \\    #
+   /' /\\  \\   #
+  //  __'  \\  #
+ /   /  \\\\  \\ #
+(___/    \\___)#
+              ##
+ _______   #
+|   _  "\\  #
+(. |_)  :) #
+|:     \\/  #
+(|  _  \\\\  #
+|: |_)  :) #
+(_______/  #
+           ##
+  ______   #
+ /" _  "\\  #
+(: ( \\___) #
+ \\/ \\      #
+ //  \\ _   #
+(:   _) \\  #
+ \\_______) #
+           ##
+ ________   #
+|"      "\\  #
+(.  ___  :) #
+|: \\   ) || #
+(| (___\\ || #
+|:       :) #
+(________/  #
+            ##
+  _______  #
+ /"     "| #
+(: ______) #
+ \\/    |   #
+ // ___)_  #
+(:      "| #
+ \\_______) #
+           ##
+  _______  #
+ /"     "| #
+(: ______) #
+ \\/    |   #
+ // ___)   #
+(:  (      #
+ \\__/      #
+           ##
+  _______   #
+ /" _   "|  #
+(: ( \\___)  #
+ \\/ \\       #
+ //  \\ ___  #
+(:   _(  _| #
+ \\_______)  #
+            ##
+  __    __   #
+ /" |  | "\\  #
+(:  (__)  :) #
+ \\/      \\/  #
+ //  __  \\\\  #
+(:  (  )  :) #
+ \\__|  |__/  #
+             ##
+  __     #
+ |" \\    #
+ ||  |   #
+ |:  |   #
+ |.  |   #
+ /\\  |\\  #
+(__\\_|_) #
+         ##
+      ___  #
+     |"  | #
+     ||  | #
+     |:  | #
+  ___|  /  #
+ /  :|_/ ) #
+(_______/  #
+           ##
+ __   ___  #
+|/"| /  ") #
+(: |/   /  #
+|    __/   #
+(// _  \\   #
+|: | \\  \\  #
+(__|  \\__) #
+           ##
+ ___       #
+|"  |      #
+||  |      #
+|:  |      #
+ \\  |___   #
+( \\_|:  \\  #
+ \\_______) #
+           ##
+ ___      ___ #
+|"  \\    /"  |#
+ \\   \\  //   |#
+ /\\\\  \\/.    |#
+|: \\.        |#
+|.  \\    /:  |#
+|___|\\__/|___|#
+              ##
+ _____  ___   #
+(\\"   \\|"  \\  #
+|.\\\\   \\    | #
+|: \\.   \\\\  | #
+|.  \\    \\. | #
+|    \\    \\ | #
+ \\___|\\____\\) #
+              ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    ) :) #
+(: (____/ //  #
+ \\        /   #
+  \\"_____/    #
+              ##
+   _______   #
+  |   __ "\\  #
+  (. |__) :) #
+  |:  ____/  #
+  (|  /      #
+ /|__/ \\     #
+(_______)    #
+             ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    )  ) #
+(: (____/ //  #
+ \\         \\  #
+  \\"____/\\__\\ #
+              ##
+  _______   #
+ /"      \\  #
+|:        | #
+|_____/   ) #
+ //      /  #
+|:  __   \\  #
+|__|  \\___) #
+            ##
+  ________  #
+ /"       ) #
+(:   \\___/  #
+ \\___  \\    #
+  __/  \\\\   #
+ /" \\   :)  #
+(_______/   #
+            ##
+ ___________  #
+("     _   ") #
+ )__/  \\\\__/  #
+    \\\\_ /     #
+    |.  |     #
+    \\:  |     #
+     \\__|     #
+              ##
+ ____  ____  #
+("  _||_ " | #
+|   (  ) : | #
+(:  |  | . ) #
+ \\\\ \\__/ //  #
+ /\\\\ __ //\\  #
+(__________) #
+             ##
+ ___      ___ #
+|"  \\    /"  |#
+ \\   \\  //  / #
+  \\\\  \\/. ./  #
+   \\.    //   #
+    \\\\   /    #
+     \\__/     #
+              ##
+ __   __  ___ #
+|"  |/  \\|  "|#
+|'  /    \\:  |#
+|: /'        |#
+ \\//  /\\'    |#
+ /   /  \\\\   |#
+|___/    \\___|#
+              ##
+ ___  ___  #
+|"  \\/"  | #
+ \\   \\  /  #
+  \\\\  \\/   #
+  /\\.  \\   #
+ /  \\   \\  #
+|___/\\___| #
+           ##
+ ___  ___  #
+|"  \\/"  | #
+ \\   \\  /  #
+  \\\\  \\/   #
+  /   /    #
+ /   /     #
+|___/      #
+           ##
+ ________   #
+("      "\\  #
+ \\___/   :) #
+   /  ___/  #
+  //  \\__   #
+ (:   / "\\  #
+  \\_______) #
+            ##
+  ________  #
+ /"      ") #
+(:   \\___/  #
+//   /      #
+\\\\   \\___   #
+(:   /  "\\  #
+ \\________) #
+            ##
+ ___       #
+|  "\\      #
+ \\\\  \\     #
+  \\  '\\    #
+   \\  \\\\   #
+    \\\\  \\  #
+     \\___| #
+           ##
+ ________   #
+("      "\\  #
+ \\___/   :) #
+     \\   \\\\ #
+  ___/   // #
+ /"  \\   :) #
+(________/  #
+            ##
+   __    #
+  /""\\   #
+ //   \\  #
+/'_/\\_\\\\ #
+         #
+         #
+         #
+         ##
+_#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+ _____   #
+("   \\\\  #
+ \\_____) #
+         #
+         #
+         #
+         #
+         ##
+      __      #
+     /""\\     #
+    /    \\    #
+   /' /\\  \\   #
+  //  __'  \\  #
+ /   /  \\\\  \\ #
+(___/    \\___)#
+              ##
+ _______   #
+|   _  "\\  #
+(. |_)  :) #
+|:     \\/  #
+(|  _  \\\\  #
+|: |_)  :) #
+(_______/  #
+           ##
+  ______   #
+ /" _  "\\  #
+(: ( \\___) #
+ \\/ \\      #
+ //  \\ _   #
+(:   _) \\  #
+ \\_______) #
+           ##
+ ________   #
+|"      "\\  #
+(.  ___  :) #
+|: \\   ) || #
+(| (___\\ || #
+|:       :) #
+(________/  #
+            ##
+  _______  #
+ /"     "| #
+(: ______) #
+ \\/    |   #
+ // ___)_  #
+(:      "| #
+ \\_______) #
+           ##
+  _______  #
+ /"     "| #
+(: ______) #
+ \\/    |   #
+ // ___)   #
+(:  (      #
+ \\__/      #
+           ##
+  _______   #
+ /" _   "|  #
+(: ( \\___)  #
+ \\/ \\       #
+ //  \\ ___  #
+(:   _(  _| #
+ \\_______)  #
+            ##
+  __    __   #
+ /" |  | "\\  #
+(:  (__)  :) #
+ \\/      \\/  #
+ //  __  \\\\  #
+(:  (  )  :) #
+ \\__|  |__/  #
+             ##
+  __     #
+ |" \\    #
+ ||  |   #
+ |:  |   #
+ |.  |   #
+ /\\  |\\  #
+(__\\_|_) #
+         ##
+      ___  #
+     |"  | #
+     ||  | #
+     |:  | #
+  ___|  /  #
+ /  :|_/ ) #
+(_______/  #
+           ##
+ __   ___  #
+|/"| /  ") #
+(: |/   /  #
+|    __/   #
+(// _  \\   #
+|: | \\  \\  #
+(__|  \\__) #
+           ##
+ ___       #
+|"  |      #
+||  |      #
+|:  |      #
+ \\  |___   #
+( \\_|:  \\  #
+ \\_______) #
+           ##
+ ___      ___ #
+|"  \\    /"  |#
+ \\   \\  //   |#
+ /\\\\  \\/.    |#
+|: \\.        |#
+|.  \\    /:  |#
+|___|\\__/|___|#
+              ##
+ _____  ___   #
+(\\"   \\|"  \\  #
+|.\\\\   \\    | #
+|: \\.   \\\\  | #
+|.  \\    \\. | #
+|    \\    \\ | #
+ \\___|\\____\\) #
+              ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    ) :) #
+(: (____/ //  #
+ \\        /   #
+  \\"_____/    #
+              ##
+   _______   #
+  |   __ "\\  #
+  (. |__) :) #
+  |:  ____/  #
+  (|  /      #
+ /|__/ \\     #
+(_______)    #
+             ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    )  ) #
+(: (____/ //  #
+ \\         \\  #
+  \\"____/\\__\\ #
+              ##
+  _______   #
+ /"      \\  #
+|:        | #
+|_____/   ) #
+ //      /  #
+|:  __   \\  #
+|__|  \\___) #
+            ##
+  ________  #
+ /"       ) #
+(:   \\___/  #
+ \\___  \\    #
+  __/  \\\\   #
+ /" \\   :)  #
+(_______/   #
+            ##
+ ___________  #
+("     _   ") #
+ )__/  \\\\__/  #
+    \\\\_ /     #
+    |.  |     #
+    \\:  |     #
+     \\__|     #
+              ##
+ ____  ____  #
+("  _||_ " | #
+|   (  ) : | #
+(:  |  | . ) #
+ \\\\ \\__/ //  #
+ /\\\\ __ //\\  #
+(__________) #
+             ##
+ ___      ___ #
+|"  \\    /"  |#
+ \\   \\  //  / #
+  \\\\  \\/. ./  #
+   \\.    //   #
+    \\\\   /    #
+     \\__/     #
+              ##
+ __   __  ___ #
+|"  |/  \\|  "|#
+|'  /    \\:  |#
+|: /'        |#
+ \\//  /\\'    |#
+ /   /  \\\\   |#
+|___/    \\___|#
+              ##
+ ___  ___  #
+|"  \\/"  | #
+ \\   \\  /  #
+  \\\\  \\/   #
+  /\\.  \\   #
+ /  \\   \\  #
+|___/\\___| #
+           ##
+ ___  ___  #
+|"  \\/"  | #
+ \\   \\  /  #
+  \\\\  \\/   #
+  /   /    #
+ /   /     #
+|___/      #
+           ##
+ ________   #
+("      "\\  #
+ \\___/   :) #
+   /  ___/  #
+  //  \\__   #
+ (:   / "\\  #
+  \\_______) #
+            ##
+  ________  #
+ /"      ") #
+(:   \\___/  #
+ \\\\  /      #
+ //  \\___   #
+(:   /  "\\  #
+ \\________) #
+            ##
+ __   #
+|" \\  #
+||  | #
+|:  | #
+|.  | #
+|   | #
+\\___) #
+      ##
+ ________   #
+("      "\\  #
+ \\___/   :) #
+     \\  //  #
+  ___/  \\\\  #
+ /"  \\   :) #
+(________/  #
+            ##
+~#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##
+      __      #
+     /""\\     #
+    /    \\    #
+   /' /\\  \\   #
+  //  __'  \\  #
+ /   /  \\\\  \\ #
+(___/    \\___)#
+              ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    ) :) #
+(: (____/ //  #
+ \\        /   #
+  \\"_____/    #
+              ##
+ ____  ____  #
+("  _||_ " | #
+|   (  ) : | #
+(:  |  | . ) #
+ \\\\ \\__/ //  #
+ /\\\\ __ //\\  #
+(__________) #
+             ##
+      __      #
+     /""\\     #
+    /    \\    #
+   /' /\\  \\   #
+  //  __'  \\  #
+ /   /  \\\\  \\ #
+(___/    \\___)#
+              ##
+    ______    #
+   /    " \\   #
+  // ____  \\  #
+ /  /    ) :) #
+(: (____/ //  #
+ \\        /   #
+  \\"_____/    #
+              ##
+ ____  ____  #
+("  _||_ " | #
+|   (  ) : | #
+(:  |  | . ) #
+ \\\\ \\__/ //  #
+ /\\\\ __ //\\  #
+(__________) #
+             ##
+�#
+ #
+ #
+ #
+ #
+ #
+ #
+ ##`

.pnpm-store/v11/files/5d/dc1ae83cd6e1c1ce37f0e34077ac1b0e9857b6220ad2141bb80746b3ab132201ae3855572acad63839a4c983cbe93785cc06f448bc4b3dc22d817a7b1d6b0d

@@ -0,0 +1,313 @@
+// Copyright 2017 Lovell Fuller and others.
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict';
+
+const childProcess = require('child_process');
+const { isLinux, getReport } = require('./process');
+const { LDD_PATH, SELF_PATH, readFile, readFileSync } = require('./filesystem');
+const { interpreterPath } = require('./elf');
+
+let cachedFamilyInterpreter;
+let cachedFamilyFilesystem;
+let cachedVersionFilesystem;
+
+const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';
+let commandOut = '';
+
+const safeCommand = () => {
+  if (!commandOut) {
+    return new Promise((resolve) => {
+      childProcess.exec(command, (err, out) => {
+        commandOut = err ? ' ' : out;
+        resolve(commandOut);
+      });
+    });
+  }
+  return commandOut;
+};
+
+const safeCommandSync = () => {
+  if (!commandOut) {
+    try {
+      commandOut = childProcess.execSync(command, { encoding: 'utf8' });
+    } catch (_err) {
+      commandOut = ' ';
+    }
+  }
+  return commandOut;
+};
+
+/**
+ * A String constant containing the value `glibc`.
+ * @type {string}
+ * @public
+ */
+const GLIBC = 'glibc';
+
+/**
+ * A Regexp constant to get the GLIBC Version.
+ * @type {string}
+ */
+const RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+
+/**
+ * A String constant containing the value `musl`.
+ * @type {string}
+ * @public
+ */
+const MUSL = 'musl';
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');
+
+const familyFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return GLIBC;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return MUSL;
+    }
+  }
+  return null;
+};
+
+const familyFromCommand = (out) => {
+  const [getconf, ldd1] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return GLIBC;
+  }
+  if (ldd1 && ldd1.includes(MUSL)) {
+    return MUSL;
+  }
+  return null;
+};
+
+const familyFromInterpreterPath = (path) => {
+  if (path) {
+    if (path.includes('/ld-musl-')) {
+      return MUSL;
+    } else if (path.includes('/ld-linux-')) {
+      return GLIBC;
+    }
+  }
+  return null;
+};
+
+const getFamilyFromLddContent = (content) => {
+  content = content.toString();
+  if (content.includes('musl')) {
+    return MUSL;
+  }
+  if (content.includes('GNU C Library')) {
+    return GLIBC;
+  }
+  return null;
+};
+
+const familyFromFilesystem = async () => {
+  if (cachedFamilyFilesystem !== undefined) {
+    return cachedFamilyFilesystem;
+  }
+  cachedFamilyFilesystem = null;
+  try {
+    const lddContent = await readFile(LDD_PATH);
+    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+  } catch (e) {}
+  return cachedFamilyFilesystem;
+};
+
+const familyFromFilesystemSync = () => {
+  if (cachedFamilyFilesystem !== undefined) {
+    return cachedFamilyFilesystem;
+  }
+  cachedFamilyFilesystem = null;
+  try {
+    const lddContent = readFileSync(LDD_PATH);
+    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+  } catch (e) {}
+  return cachedFamilyFilesystem;
+};
+
+const familyFromInterpreter = async () => {
+  if (cachedFamilyInterpreter !== undefined) {
+    return cachedFamilyInterpreter;
+  }
+  cachedFamilyInterpreter = null;
+  try {
+    const selfContent = await readFile(SELF_PATH);
+    const path = interpreterPath(selfContent);
+    cachedFamilyInterpreter = familyFromInterpreterPath(path);
+  } catch (e) {}
+  return cachedFamilyInterpreter;
+};
+
+const familyFromInterpreterSync = () => {
+  if (cachedFamilyInterpreter !== undefined) {
+    return cachedFamilyInterpreter;
+  }
+  cachedFamilyInterpreter = null;
+  try {
+    const selfContent = readFileSync(SELF_PATH);
+    const path = interpreterPath(selfContent);
+    cachedFamilyInterpreter = familyFromInterpreterPath(path);
+  } catch (e) {}
+  return cachedFamilyInterpreter;
+};
+
+/**
+ * Resolves with the libc family when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const family = async () => {
+  let family = null;
+  if (isLinux()) {
+    family = await familyFromInterpreter();
+    if (!family) {
+      family = await familyFromFilesystem();
+      if (!family) {
+        family = familyFromReport();
+      }
+      if (!family) {
+        const out = await safeCommand();
+        family = familyFromCommand(out);
+      }
+    }
+  }
+  return family;
+};
+
+/**
+ * Returns the libc family when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const familySync = () => {
+  let family = null;
+  if (isLinux()) {
+    family = familyFromInterpreterSync();
+    if (!family) {
+      family = familyFromFilesystemSync();
+      if (!family) {
+        family = familyFromReport();
+      }
+      if (!family) {
+        const out = safeCommandSync();
+        family = familyFromCommand(out);
+      }
+    }
+  }
+  return family;
+};
+
+/**
+ * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {Promise<boolean>}
+ */
+const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+
+/**
+ * Returns `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {boolean}
+ */
+const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+
+const versionFromFilesystem = async () => {
+  if (cachedVersionFilesystem !== undefined) {
+    return cachedVersionFilesystem;
+  }
+  cachedVersionFilesystem = null;
+  try {
+    const lddContent = await readFile(LDD_PATH);
+    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+    if (versionMatch) {
+      cachedVersionFilesystem = versionMatch[1];
+    }
+  } catch (e) {}
+  return cachedVersionFilesystem;
+};
+
+const versionFromFilesystemSync = () => {
+  if (cachedVersionFilesystem !== undefined) {
+    return cachedVersionFilesystem;
+  }
+  cachedVersionFilesystem = null;
+  try {
+    const lddContent = readFileSync(LDD_PATH);
+    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+    if (versionMatch) {
+      cachedVersionFilesystem = versionMatch[1];
+    }
+  } catch (e) {}
+  return cachedVersionFilesystem;
+};
+
+const versionFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return report.header.glibcVersionRuntime;
+  }
+  return null;
+};
+
+const versionSuffix = (s) => s.trim().split(/\s+/)[1];
+
+const versionFromCommand = (out) => {
+  const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return versionSuffix(getconf);
+  }
+  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+    return versionSuffix(ldd2);
+  }
+  return null;
+};
+
+/**
+ * Resolves with the libc version when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const version = async () => {
+  let version = null;
+  if (isLinux()) {
+    version = await versionFromFilesystem();
+    if (!version) {
+      version = versionFromReport();
+    }
+    if (!version) {
+      const out = await safeCommand();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
+
+/**
+ * Returns the libc version when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const versionSync = () => {
+  let version = null;
+  if (isLinux()) {
+    version = versionFromFilesystemSync();
+    if (!version) {
+      version = versionFromReport();
+    }
+    if (!version) {
+      const out = safeCommandSync();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
+
+module.exports = {
+  GLIBC,
+  MUSL,
+  family,
+  familySync,
+  isNonGlibcLinux,
+  isNonGlibcLinuxSync,
+  version,
+  versionSync
+};

.pnpm-store/v11/files/5d/e0b81d4f8a239b15719fb7396e417ba3b16b973a09245c7000160b561e009345ccc8c09320b39ece097ed060a4b8a80a570a2c4c4afb076eea81ceafb5bdfe

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class FileExistsPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, target) {
+		this.source = source;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		const fs = resolver.fileSystem;
+		resolver
+			.getHook(this.source)
+			.tapAsync("FileExistsPlugin", (request, resolveContext, callback) => {
+				const file = request.path;
+				if (!file) return callback();
+				fs.stat(file, (err, stat) => {
+					if (err || !stat) {
+						if (resolveContext.missingDependencies) {
+							resolveContext.missingDependencies.add(file);
+						}
+						if (resolveContext.log) resolveContext.log(`${file} doesn't exist`);
+						return callback();
+					}
+					if (!stat.isFile()) {
+						if (resolveContext.missingDependencies) {
+							resolveContext.missingDependencies.add(file);
+						}
+						if (resolveContext.log) resolveContext.log(`${file} is not a file`);
+						return callback();
+					}
+					if (resolveContext.fileDependencies) {
+						resolveContext.fileDependencies.add(file);
+					}
+					resolver.doResolve(
+						target,
+						request,
+						`existing file: ${file}`,
+						resolveContext,
+						callback,
+					);
+				});
+			});
+	}
+};

.pnpm-store/v11/files/5d/e3b849cd14bd91f43daf3a45c8960c652069a083a8b57591d1632eb8602dea6fde29b6877d3ffbe4bd351fcb1e41a59c14e438f359b9b0c4f3d54c4d3a96c9

@@ -0,0 +1 @@
+{"version":3,"file":"is-animatable.mjs","sources":["../../../../src/animation/utils/is-animatable.ts"],"sourcesContent":["import { complex } from \"../../value/types/complex\"\nimport { ValueKeyframesDefinition } from \"../types\"\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nexport const isAnimatable = (\n    value: ValueKeyframesDefinition,\n    name?: string\n) => {\n    // If the list of keys that might be non-animatable grows, replace with Set\n    if (name === \"zIndex\") return false\n\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value)) return true\n\n    if (\n        typeof value === \"string\" && // It's animatable if we have a string\n        (complex.test(value) || value === \"0\") && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true\n    }\n\n    return false\n}\n"],"names":[],"mappings":";;AAGA;;;;;;;;AAQG;MACU,YAAY,GAAG,CACxB,KAA+B,EAC/B,IAAa,KACb;;IAEA,IAAI,IAAI,KAAK,QAAQ;AAAE,QAAA,OAAO,KAAK;;;;IAKnC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;AAAE,QAAA,OAAO,IAAI;AAElE,IAAA,IACI,OAAO,KAAK,KAAK,QAAQ;AACzB,SAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,GAAG,CAAC;AACtC,QAAA,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC;MAC3B;AACE,QAAA,OAAO,IAAI;IACf;AAEA,IAAA,OAAO,KAAK;AAChB;;;;"}

.pnpm-store/v11/files/5d/f2b43acc791e025e175e74e999623cd2c3ed2ef66c9628d3f13381ee7912b17329840ba3e676f2855360fd2fad076f852c018b8d17b6af48a15f658cd5b61e

@@ -0,0 +1,585 @@
+"use strict";
+var x = Object.defineProperty;
+var G = Object.getOwnPropertyDescriptor;
+var J = Object.getOwnPropertyNames;
+var U = Object.prototype.hasOwnProperty;
+var q = (n) => {
+  throw TypeError(n);
+};
+var W = (n, s, t) => s in n ? x(n, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[s] = t;
+var X = (n, s) => {
+  for (var t in s)
+    x(n, t, { get: s[t], enumerable: !0 });
+}, Z = (n, s, t, e) => {
+  if (s && typeof s == "object" || typeof s == "function")
+    for (let r of J(s))
+      !U.call(n, r) && r !== t && x(n, r, { get: () => s[r], enumerable: !(e = G(s, r)) || e.enumerable });
+  return n;
+};
+var tt = (n) => Z(x({}, "__esModule", { value: !0 }), n);
+var M = (n, s, t) => W(n, typeof s != "symbol" ? s + "" : s, t), S = (n, s, t) => s.has(n) || q("Cannot " + t);
+var d = (n, s, t) => (S(n, s, "read from private field"), t ? t.call(n) : s.get(n)), L = (n, s, t) => s.has(n) ? q("Cannot add the same private member more than once") : s instanceof WeakSet ? s.add(n) : s.set(n, t), f = (n, s, t, e) => (S(n, s, "write to private field"), e ? e.call(n, t) : s.set(n, t), t);
+var N = (n, s, t, e) => ({
+  set _(r) {
+    f(n, s, r, t);
+  },
+  get _() {
+    return d(n, s, e);
+  }
+});
+
+// src/index.ts
+var ot = {};
+X(ot, {
+  Bench: () => k,
+  Task: () => v,
+  hrtimeNow: () => z,
+  now: () => A
+});
+module.exports = tt(ot);
+
+// node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+var B = class {
+  constructor(s) {
+    M(this, "value");
+    M(this, "next");
+    this.value = s;
+  }
+}, m, E, b, g = class {
+  constructor() {
+    L(this, m);
+    L(this, E);
+    L(this, b);
+    this.clear();
+  }
+  enqueue(s) {
+    let t = new B(s);
+    d(this, m) ? (d(this, E).next = t, f(this, E, t)) : (f(this, m, t), f(this, E, t)), N(this, b)._++;
+  }
+  dequeue() {
+    let s = d(this, m);
+    if (s)
+      return f(this, m, d(this, m).next), N(this, b)._--, s.value;
+  }
+  clear() {
+    f(this, m, void 0), f(this, E, void 0), f(this, b, 0);
+  }
+  get size() {
+    return d(this, b);
+  }
+  *[Symbol.iterator]() {
+    let s = d(this, m);
+    for (; s; )
+      yield s.value, s = s.next;
+  }
+};
+m = new WeakMap(), E = new WeakMap(), b = new WeakMap();
+
+// node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+function y(n) {
+  if (!((Number.isInteger(n) || n === Number.POSITIVE_INFINITY) && n > 0))
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  let s = new g(), t = 0, e = () => {
+    t--, s.size > 0 && s.dequeue()();
+  }, r = async (h, p, a) => {
+    t++;
+    let l = (async () => h(...a))();
+    p(l);
+    try {
+      await l;
+    } catch (T) {
+    }
+    e();
+  }, i = (h, p, a) => {
+    s.enqueue(r.bind(void 0, h, p, a)), (async () => (await Promise.resolve(), t < n && s.size > 0 && s.dequeue()()))();
+  }, c = (h, ...p) => new Promise((a) => {
+    i(h, a, p);
+  });
+  return Object.defineProperties(c, {
+    activeCount: {
+      get: () => t
+    },
+    pendingCount: {
+      get: () => s.size
+    },
+    clearQueue: {
+      value: () => {
+        s.clear();
+      }
+    }
+  }), c;
+}
+
+// src/event.ts
+function o(n, s = null) {
+  let t = new Event(n);
+  return s && Object.defineProperty(t, "task", {
+    value: s,
+    enumerable: !0,
+    writable: !1,
+    configurable: !1
+  }), t;
+}
+
+// src/constants.ts
+var et = {
+  1: 12.71,
+  2: 4.303,
+  3: 3.182,
+  4: 2.776,
+  5: 2.571,
+  6: 2.447,
+  7: 2.365,
+  8: 2.306,
+  9: 2.262,
+  10: 2.228,
+  11: 2.201,
+  12: 2.179,
+  13: 2.16,
+  14: 2.145,
+  15: 2.131,
+  16: 2.12,
+  17: 2.11,
+  18: 2.101,
+  19: 2.093,
+  20: 2.086,
+  21: 2.08,
+  22: 2.074,
+  23: 2.069,
+  24: 2.064,
+  25: 2.06,
+  26: 2.056,
+  27: 2.052,
+  28: 2.048,
+  29: 2.045,
+  30: 2.042,
+  31: 2.0399,
+  32: 2.0378,
+  33: 2.0357,
+  34: 2.0336,
+  35: 2.0315,
+  36: 2.0294,
+  37: 2.0273,
+  38: 2.0252,
+  39: 2.0231,
+  40: 2.021,
+  41: 2.0198,
+  42: 2.0186,
+  43: 2.0174,
+  44: 2.0162,
+  45: 2.015,
+  46: 2.0138,
+  47: 2.0126,
+  48: 2.0114,
+  49: 2.0102,
+  50: 2.009,
+  51: 2.0081,
+  52: 2.0072,
+  53: 2.0063,
+  54: 2.0054,
+  55: 2.0045,
+  56: 2.0036,
+  57: 2.0027,
+  58: 2.0018,
+  59: 2.0009,
+  60: 2,
+  61: 1.9995,
+  62: 1.999,
+  63: 1.9985,
+  64: 1.998,
+  65: 1.9975,
+  66: 1.997,
+  67: 1.9965,
+  68: 1.996,
+  69: 1.9955,
+  70: 1.995,
+  71: 1.9945,
+  72: 1.994,
+  73: 1.9935,
+  74: 1.993,
+  75: 1.9925,
+  76: 1.992,
+  77: 1.9915,
+  78: 1.991,
+  79: 1.9905,
+  80: 1.99,
+  81: 1.9897,
+  82: 1.9894,
+  83: 1.9891,
+  84: 1.9888,
+  85: 1.9885,
+  86: 1.9882,
+  87: 1.9879,
+  88: 1.9876,
+  89: 1.9873,
+  90: 1.987,
+  91: 1.9867,
+  92: 1.9864,
+  93: 1.9861,
+  94: 1.9858,
+  95: 1.9855,
+  96: 1.9852,
+  97: 1.9849,
+  98: 1.9846,
+  99: 1.9843,
+  100: 1.984,
+  101: 1.9838,
+  102: 1.9836,
+  103: 1.9834,
+  104: 1.9832,
+  105: 1.983,
+  106: 1.9828,
+  107: 1.9826,
+  108: 1.9824,
+  109: 1.9822,
+  110: 1.982,
+  111: 1.9818,
+  112: 1.9816,
+  113: 1.9814,
+  114: 1.9812,
+  115: 1.9819,
+  116: 1.9808,
+  117: 1.9806,
+  118: 1.9804,
+  119: 1.9802,
+  120: 1.98,
+  infinity: 1.96
+}, P = et;
+
+// src/utils.ts
+var st = (n) => n / 1e6, z = () => st(Number(process.hrtime.bigint())), A = () => performance.now();
+function nt(n) {
+  return n !== null && typeof n == "object" && typeof n.then == "function";
+}
+var j = (n, s) => n.reduce((e, r) => e + (r - s) ** 2, 0) / (n.length - 1) || 0, rt = (async () => {
+}).constructor, it = (n) => n.constructor === rt, H = async (n) => {
+  if (it(n.fn))
+    return !0;
+  try {
+    if (n.opts.beforeEach != null)
+      try {
+        await n.opts.beforeEach.call(n);
+      } catch (e) {
+      }
+    let s = n.fn(), t = nt(s);
+    if (t)
+      try {
+        await s;
+      } catch (e) {
+      }
+    if (n.opts.afterEach != null)
+      try {
+        await n.opts.afterEach.call(n);
+      } catch (e) {
+      }
+    return t;
+  } catch (s) {
+    return !1;
+  }
+};
+
+// src/task.ts
+var v = class extends EventTarget {
+  constructor(t, e, r, i = {}) {
+    super();
+    /*
+     * the number of times the task
+     * function has been executed
+     */
+    this.runs = 0;
+    this.bench = t, this.name = e, this.fn = r, this.opts = i;
+  }
+  async loop(t, e) {
+    var T;
+    let r = this.bench.concurrency === "task", { threshold: i } = this.bench, c = 0, h = [];
+    if (this.opts.beforeAll != null)
+      try {
+        await this.opts.beforeAll.call(this);
+      } catch (u) {
+        return { error: u };
+      }
+    let p = await H(this), a = async () => {
+      this.opts.beforeEach != null && await this.opts.beforeEach.call(this);
+      let u = 0;
+      if (p) {
+        let w = this.bench.now();
+        await this.fn.call(this), u = this.bench.now() - w;
+      } else {
+        let w = this.bench.now();
+        this.fn.call(this), u = this.bench.now() - w;
+      }
+      h.push(u), c += u, this.opts.afterEach != null && await this.opts.afterEach.call(this);
+    }, l = y(i);
+    try {
+      let u = [];
+      for (; (c < t || h.length + l.activeCount + l.pendingCount < e) && !((T = this.bench.signal) != null && T.aborted); )
+        r ? u.push(l(a)) : await a();
+      u.length && await Promise.all(u);
+    } catch (u) {
+      return { error: u };
+    }
+    if (this.opts.afterAll != null)
+      try {
+        await this.opts.afterAll.call(this);
+      } catch (u) {
+        return { error: u };
+      }
+    return { samples: h };
+  }
+  /**
+   * run the current task and write the results in `Task.result` object
+   */
+  async run() {
+    var r, i;
+    if ((r = this.result) != null && r.error)
+      return this;
+    this.dispatchEvent(o("start", this)), await this.bench.setup(this, "run");
+    let { samples: t, error: e } = await this.loop(this.bench.time, this.bench.iterations);
+    if (this.bench.teardown(this, "run"), t) {
+      let c = t.reduce((O, F) => O + F, 0);
+      this.runs = t.length, t.sort((O, F) => O - F);
+      let h = c / this.runs, p = 1e3 / h, a = t.length, l = a - 1, T = t[0], u = t[l], w = c / t.length || 0, R = j(t, w), I = Math.sqrt(R), _ = I / Math.sqrt(a), K = P[String(Math.round(l) || 1)] || P.infinity, C = _ * K, V = C / w * 100, Q = t[Math.ceil(a * 0.75) - 1], Y = t[Math.ceil(a * 0.99) - 1], $ = t[Math.ceil(a * 0.995) - 1], D = t[Math.ceil(a * 0.999) - 1];
+      if ((i = this.bench.signal) != null && i.aborted)
+        return this;
+      this.setResult({
+        totalTime: c,
+        min: T,
+        max: u,
+        hz: p,
+        period: h,
+        samples: t,
+        mean: w,
+        variance: R,
+        sd: I,
+        sem: _,
+        df: l,
+        critical: K,
+        moe: C,
+        rme: V,
+        p75: Q,
+        p99: Y,
+        p995: $,
+        p999: D
+      });
+    }
+    if (e) {
+      if (this.setResult({ error: e }), this.bench.throws)
+        throw e;
+      this.dispatchEvent(o("error", this)), this.bench.dispatchEvent(o("error", this));
+    }
+    return this.dispatchEvent(o("cycle", this)), this.bench.dispatchEvent(o("cycle", this)), this.dispatchEvent(o("complete", this)), this;
+  }
+  /**
+   * warmup the current task
+   */
+  async warmup() {
+    var e;
+    if ((e = this.result) != null && e.error)
+      return;
+    this.dispatchEvent(o("warmup", this)), await this.bench.setup(this, "warmup");
+    let { error: t } = await this.loop(this.bench.warmupTime, this.bench.warmupIterations);
+    if (this.bench.teardown(this, "warmup"), t && (this.setResult({ error: t }), this.bench.throws))
+      throw t;
+  }
+  addEventListener(t, e, r) {
+    super.addEventListener(t, e, r);
+  }
+  removeEventListener(t, e, r) {
+    super.removeEventListener(t, e, r);
+  }
+  /**
+   * change the result object values
+   */
+  setResult(t) {
+    this.result = { ...this.result, ...t }, Object.freeze(this.result);
+  }
+  /**
+   * reset the task to make the `Task.runs` a zero-value and remove the `Task.result`
+   * object
+   */
+  reset() {
+    this.dispatchEvent(o("reset", this)), this.runs = 0, this.result = void 0;
+  }
+};
+
+// src/bench.ts
+var k = class extends EventTarget {
+  constructor(t = {}) {
+    var e, r, i, c, h, p, a, l;
+    super();
+    /*
+     * @private the task map
+     */
+    this._tasks = /* @__PURE__ */ new Map();
+    this._todos = /* @__PURE__ */ new Map();
+    /**
+    * Executes tasks concurrently based on the specified concurrency mode.
+    *
+    * - When `mode` is set to `null` (default), concurrency is disabled.
+    * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
+    * - When `mode` is set to 'bench', different tasks within the bench run concurrently.
+    */
+    this.concurrency = null;
+    /**
+     * The maximum number of concurrent tasks to run. Defaults to Infinity.
+     */
+    this.threshold = 1 / 0;
+    this.warmupTime = 100;
+    this.warmupIterations = 5;
+    this.time = 500;
+    this.iterations = 10;
+    this.now = A;
+    this.now = (e = t.now) != null ? e : this.now, this.warmupTime = (r = t.warmupTime) != null ? r : this.warmupTime, this.warmupIterations = (i = t.warmupIterations) != null ? i : this.warmupIterations, this.time = (c = t.time) != null ? c : this.time, this.iterations = (h = t.iterations) != null ? h : this.iterations, this.signal = t.signal, this.throws = (p = t.throws) != null ? p : !1, this.setup = (a = t.setup) != null ? a : () => {
+    }, this.teardown = (l = t.teardown) != null ? l : () => {
+    }, this.signal && this.signal.addEventListener(
+      "abort",
+      () => {
+        this.dispatchEvent(o("abort"));
+      },
+      { once: !0 }
+    );
+  }
+  runTask(t) {
+    var e;
+    return (e = this.signal) != null && e.aborted ? t : t.run();
+  }
+  /**
+   * run the added tasks that were registered using the
+   * {@link add} method.
+   * Note: This method does not do any warmup. Call {@link warmup} for that.
+   */
+  async run() {
+    if (this.concurrency === "bench")
+      return this.runConcurrently(this.threshold, this.concurrency);
+    this.dispatchEvent(o("start"));
+    let t = [];
+    for (let e of [...this._tasks.values()])
+      t.push(await this.runTask(e));
+    return this.dispatchEvent(o("complete")), t;
+  }
+  /**
+   * See Bench.{@link concurrency}
+   */
+  async runConcurrently(t = 1 / 0, e = "bench") {
+    if (this.threshold = t, this.concurrency = e, e === "task")
+      return this.run();
+    this.dispatchEvent(o("start"));
+    let r = y(t), i = [];
+    for (let h of [...this._tasks.values()])
+      i.push(r(() => this.runTask(h)));
+    let c = await Promise.all(i);
+    return this.dispatchEvent(o("complete")), c;
+  }
+  /**
+   * warmup the benchmark tasks.
+   * This is not run by default by the {@link run} method.
+   */
+  async warmup() {
+    if (this.concurrency === "bench") {
+      await this.warmupConcurrently(this.threshold, this.concurrency);
+      return;
+    }
+    this.dispatchEvent(o("warmup"));
+    for (let [, t] of this._tasks)
+      await t.warmup();
+  }
+  /**
+   * warmup the benchmark tasks concurrently.
+   * This is not run by default by the {@link runConcurrently} method.
+   */
+  async warmupConcurrently(t = 1 / 0, e = "bench") {
+    if (this.threshold = t, this.concurrency = e, e === "task") {
+      await this.warmup();
+      return;
+    }
+    this.dispatchEvent(o("warmup"));
+    let r = y(t), i = [];
+    for (let [, c] of this._tasks)
+      i.push(r(() => c.warmup()));
+    await Promise.all(i);
+  }
+  /**
+   * reset each task and remove its result
+   */
+  reset() {
+    this.dispatchEvent(o("reset")), this._tasks.forEach((t) => {
+      t.reset();
+    });
+  }
+  /**
+   * add a benchmark task to the task map
+   */
+  add(t, e, r = {}) {
+    let i = new v(this, t, e, r);
+    return this._tasks.set(t, i), this.dispatchEvent(o("add", i)), this;
+  }
+  /**
+   * add a benchmark todo to the todo map
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  todo(t, e = () => {
+  }, r = {}) {
+    let i = new v(this, t, e, r);
+    return this._todos.set(t, i), this.dispatchEvent(o("todo", i)), this;
+  }
+  /**
+   * remove a benchmark task from the task map
+   */
+  remove(t) {
+    let e = this.getTask(t);
+    return e && (this.dispatchEvent(o("remove", e)), this._tasks.delete(t)), this;
+  }
+  addEventListener(t, e, r) {
+    super.addEventListener(t, e, r);
+  }
+  removeEventListener(t, e, r) {
+    super.removeEventListener(t, e, r);
+  }
+  /**
+   * table of the tasks results
+   */
+  table(t) {
+    return this.tasks.map((e) => {
+      if (e.result) {
+        if (e.result.error)
+          throw e.result.error;
+        return (t == null ? void 0 : t(e)) || {
+          "Task Name": e.name,
+          "ops/sec": e.result.error ? "NaN" : parseInt(e.result.hz.toString(), 10).toLocaleString(),
+          "Average Time (ns)": e.result.error ? "NaN" : e.result.mean * 1e3 * 1e3,
+          Margin: e.result.error ? "NaN" : `\xB1${e.result.rme.toFixed(2)}%`,
+          Samples: e.result.error ? "NaN" : e.result.samples.length
+        };
+      }
+      return null;
+    });
+  }
+  /**
+   * (getter) tasks results as an array
+   */
+  get results() {
+    return [...this._tasks.values()].map((t) => t.result);
+  }
+  /**
+   * (getter) tasks as an array
+   */
+  get tasks() {
+    return [...this._tasks.values()];
+  }
+  get todos() {
+    return [...this._todos.values()];
+  }
+  /**
+   * get a task based on the task name
+   */
+  getTask(t) {
+    return this._tasks.get(t);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Bench,
+  Task,
+  hrtimeNow,
+  now
+});

.pnpm-store/v11/files/5d/f35a2825fdd95939dd0bde413b22c9ac746516cd42d01249eeedb25c085f9ccf72b4e196fa8d8bd13fb9907243fbf7a0e3c7a61c770c1f44b14af7e7ca03cf

@@ -0,0 +1,22 @@
+/**
+ * @license lucide-react v0.469.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+import createLucideIcon from '../createLucideIcon.js';
+
+const Inbox = createLucideIcon("Inbox", [
+  ["polyline", { points: "22 12 16 12 14 15 10 15 8 12 2 12", key: "o97t9d" }],
+  [
+    "path",
+    {
+      d: "M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z",
+      key: "oot6mr"
+    }
+  ]
+]);
+
+export { Inbox as default };
+//# sourceMappingURL=inbox.js.map

.pnpm-store/v11/files/5d/f36a4d3de7942219100c98ed8c47294c6e79706b2eaab152529513091f5dfce3cb700251778035e4e8edfa80fbadcda4cd4659e92c571c12c985024888db4d

@@ -0,0 +1,630 @@
+export default `flf2a$ 6 5 17 -1 16
+
+                  "Sub-Zero" font by Sub-Zero
+                 ==============================
+
+
+-> Conversion to FigLet font by MEPH. (Part of ASCII Editor Service Pack I)
+   (http://studenten.freepage.de/meph/ascii/ascii/editor/_index.htm)
+-> Defined: ASCII code alphabet
+-> Uppercase characters only.
+
+ScarecrowsASCIIArtArchive1.0.txt
+From: "Sub-Zero" <bodom@papaya.ucs.indiana.edu>
+"Here's a font I've been working on lately.  Can someone make the V, Q, and X
+look better?  Also, the B, P, and R could use an improvement too.
+Oh, here it is."
+
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+ ______    @
+/\\  __ \\   @
+\\ \\  __ \\  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ ______    @
+/\\  == \\   @
+\\ \\  __<   @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______    @
+/\\  ___\\   @
+\\ \\ \\____  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ _____    @
+/\\  __-.  @
+\\ \\ \\/\\ \\ @
+ \\ \\____- @
+  \\/____/ @
+          @@
+ ______    @
+/\\  ___\\   @
+\\ \\  __\\   @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\  ___\\ @
+\\ \\  __\\ @
+ \\ \\_\\   @
+  \\/_/   @
+         @@
+ ______    @
+/\\  ___\\   @
+\\ \\ \\__ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __  __    @
+/\\ \\_\\ \\   @
+\\ \\  __ \\  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __    @
+/\\ \\   @
+\\ \\ \\  @
+ \\ \\_\\ @
+  \\/_/ @
+       @@
+   __    @
+  /\\ \\   @
+ _\\_\\ \\  @
+/\\_____\\ @
+\\/_____/ @
+         @@
+ __  __    @
+/\\ \\/ /    @
+\\ \\  _"-.  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __        @
+/\\ \\       @
+\\ \\ \\____  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __    __    @
+/\\ "-./  \\   @
+\\ \\ \\-./\\ \\  @
+ \\ \\_\\ \\ \\_\\ @
+  \\/_/  \\/_/ @
+             @@
+ __   __    @
+/\\ "-.\\ \\   @
+\\ \\ \\-.  \\  @
+ \\ \\_\\\\"\\_\\ @
+  \\/_/ \\/_/ @
+            @@
+ ______    @
+/\\  __ \\   @
+\\ \\ \\/\\ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\  == \\ @
+\\ \\  _-/ @
+ \\ \\_\\   @
+  \\/_/   @
+         @@
+ ______    @
+/\\  __ \\   @
+\\ \\ \\/\\_\\  @
+ \\ \\___\\_\\ @
+  \\/___/_/ @
+           @@
+ ______    @
+/\\  == \\   @
+\\ \\  __<   @
+ \\ \\_\\ \\_\\ @
+  \\/_/ /_/ @
+           @@
+ ______    @
+/\\  ___\\   @
+\\ \\___  \\  @
+ \\/\\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\__  _\\ @
+\\/_/\\ \\/ @
+   \\ \\_\\ @
+    \\/_/ @
+         @@
+ __  __    @
+/\\ \\/\\ \\   @
+\\ \\ \\_\\ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __   __  @
+/\\ \\ / /  @
+\\ \\ \\'/   @
+ \\ \\__|   @
+  \\/_/    @
+          @@
+ __     __    @
+/\\ \\  _ \\ \\   @
+\\ \\ \\/ ".\\ \\  @
+ \\ \\__/".~\\_\\ @
+  \\/_/   \\/_/ @
+              @@
+ __  __    @
+/\\_\\_\\_\\   @
+\\/_/\\_\\/_  @
+  /\\_\\/\\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __  __    @
+/\\ \\_\\ \\   @
+\\ \\____ \\  @
+ \\/\\_____\\ @
+  \\/_____/ @
+           @@
+ ______    @
+/\\___  \\   @
+\\/_/  /__  @
+  /\\_____\\ @
+  \\/_____/ @
+           @@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+ ______    @
+/\\  __ \\   @
+\\ \\  __ \\  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ ______    @
+/\\  == \\   @
+\\ \\  __<   @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______    @
+/\\  ___\\   @
+\\ \\ \\____  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ _____    @
+/\\  __-.  @
+\\ \\ \\/\\ \\ @
+ \\ \\____- @
+  \\/____/ @
+          @@
+ ______    @
+/\\  ___\\   @
+\\ \\  __\\   @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\  ___\\ @
+\\ \\  __\\ @
+ \\ \\_\\   @
+  \\/_/   @
+         @@
+ ______    @
+/\\  ___\\   @
+\\ \\ \\__ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __  __    @
+/\\ \\_\\ \\   @
+\\ \\  __ \\  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __    @
+/\\ \\   @
+\\ \\ \\  @
+ \\ \\_\\ @
+  \\/_/ @
+       @@
+   __    @
+  /\\ \\   @
+ _\\_\\ \\  @
+/\\_____\\ @
+\\/_____/ @
+         @@
+ __  __    @
+/\\ \\/ /    @
+\\ \\  _"-.  @
+ \\ \\_\\ \\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __        @
+/\\ \\       @
+\\ \\ \\____  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __    __    @
+/\\ "-./  \\   @
+\\ \\ \\-./\\ \\  @
+ \\ \\_\\ \\ \\_\\ @
+  \\/_/  \\/_/ @
+             @@
+ __   __    @
+/\\ "-.\\ \\   @
+\\ \\ \\-.  \\  @
+ \\ \\_\\\\"\\_\\ @
+  \\/_/ \\/_/ @
+            @@
+ ______    @
+/\\  __ \\   @
+\\ \\ \\/\\ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\  == \\ @
+\\ \\  _-/ @
+ \\ \\_\\   @
+  \\/_/   @
+         @@
+ ______    @
+/\\  __ \\   @
+\\ \\ \\/\\_\\  @
+ \\ \\___\\_\\ @
+  \\/___/_/ @
+           @@
+ ______    @
+/\\  == \\   @
+\\ \\  __<   @
+ \\ \\_\\ \\_\\ @
+  \\/_/ /_/ @
+           @@
+ ______    @
+/\\  ___\\   @
+\\ \\___  \\  @
+ \\/\\_____\\ @
+  \\/_____/ @
+           @@
+ ______  @
+/\\__  _\\ @
+\\/_/\\ \\/ @
+   \\ \\_\\ @
+    \\/_/ @
+         @@
+ __  __    @
+/\\ \\/\\ \\   @
+\\ \\ \\_\\ \\  @
+ \\ \\_____\\ @
+  \\/_____/ @
+           @@
+ __   __  @
+/\\ \\ / /  @
+\\ \\ \\'/   @
+ \\ \\__|   @
+  \\/_/    @
+          @@
+ __     __    @
+/\\ \\  _ \\ \\   @
+\\ \\ \\/ ".\\ \\  @
+ \\ \\__/".~\\_\\ @
+  \\/_/   \\/_/ @
+              @@
+ __  __    @
+/\\_\\_\\_\\   @
+\\/_/\\_\\/_  @
+  /\\_\\/\\_\\ @
+  \\/_/\\/_/ @
+           @@
+ __  __    @
+/\\ \\_\\ \\   @
+\\ \\____ \\  @
+ \\/\\_____\\ @
+  \\/_____/ @
+           @@
+ ______    @
+/\\___  \\   @
+\\/_/  /__  @
+  /\\_____\\ @
+  \\/_____/ @
+           @@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+`

.pnpm-store/v11/files/5d/f383e617e5beb7c2f2143141347a12d20f42d57c3f75014d74b321ff038dd14280df08ca1c868f2a8ed347030a7ba6b7af593a06171fcdfc5c24b6878c3110

@@ -0,0 +1,643 @@
+flf2a$ 6 5 16 0 30
+//-----------------------------------------------------------//
+//                                                           //
+//    .dBBBBP dBBBBBBP dBBBBBb   dBBBBBb                     //
+//    BP                    BB       dBP                     //
+//    `BBBBb   dBP      dBP BB   dBBBBK                      //
+//       dBP  dBP      dBP  BB  dBP  BB                      //
+//  dBBBBP'  dBP      dBBBBBBB dBP  dB'                      //
+//                                                           //
+//                dBBBBBBP dBBBBBb   dBBBP  dBP dBP          //
+//                             dBP         dBP.dBP           //
+//                dBP     dBBBBK   dBBP   dBBBBP'            //
+//               dBP     dBP  BB  dBP    dBP BB              //
+//              dBP     dBP  dB' dBBBBP dBP dB'              //
+//                                                           //
+//                 -=[ The Figlet Font ]=-                   //
+//                                                           //
+//  [ Version 1.0 ]                                          //
+//                                                           //
+//  1994, by Peter L. Buschman                               //
+//                                                           //
+//  Please send all comments to the author at:               //
+//                                                           //
+//                                                           //
+//                        97buschmanp@alma.edu               //
+//                        plbuschm@nyx.cs.du.edu             //
+//                                                           //
+//  OAS AAS LLS!                                             //
+//-----------------------------------------------------------//
+Height, Up_ht, Maxlength, SmushMode, CommentCount
+
+     $$$@
+    $$$ @
+   $$$  @
+  $$$   @
+ $$$    @
+$$$     @@
+     $dBP@
+    $dBP @
+   $dBP  @
+  $dBP   @
+ $       @
+$dBP     @@
+       @
+ $dP dP@
+$dP dP @
+       @
+       @
+       @@
+$     d88P  @
+$ d88888888P@
+$d8B88888BP @
+$  d88P     @
+            @
+     _      @@
+  $.===.@
+  $: |  @
+  $`===.@
+  $  | :@
+  $`==='@
+  $  "  @@
+ $dP  dP@
+ $   dP @
+ $  dP  @
+ $ dP   @
+ $dP  dP@
+        @@
+  .BBb'  @
+  B..    @
+  >BP    @
+ .B      @
+..`BB'   @
+         @@
+$   @
+$dBP@
+$BP @
+    @
+    @
+    @@
+    $.BBb.@
+   $dBP   @
+  $dBP    @
+ $dBP     @
+$dBP      @
+$`BBb     @@
+     $dBB.@
+    $  dBP@
+   $  dBP @
+  $  dBP  @
+ $  dBP   @
+$`BBB'    @@
+$    .. @
+$  .::dP@
+$  dBBP:@
+$  :dBBb@
+$  dP::'@
+$       @@
+   $    @
+  $     @
+ $  dBP @
+$dBBBBBP@
+$ dBP   @
+        @@
+   $ @
+  $  @
+ $   @
+$    @
+$$dBP@
+$$BP @@
+   $$$$$@
+  $$$$$$@
+ $$$$$$$@
+$dBBBBBP@
+$$$$$$$$@
+        @@
+    @
+   $@
+  $ @
+ $  @
+$dBP@
+    @@
+       $__@
+     $_dBP@
+   $_dBP  @
+ $_dBP    @
+$dBP      @
+          @@
+    $dBBBBP@
+   $dB'.BP @
+  $dB:.BP  @
+ $dB'.BP   @
+$dBBBBP    @
+           @@
+ $dBBBb @
+        @
+  $dBP  @
+ $dBP   @
+$dBP    @
+        @@
+ $dBBBBb@
+ $      @
+  $dBBP @
+ $dBP__ @
+$dBBBBP @
+        @@
+  $dBBBBb@
+  $      @
+  $ dBBBP@
+ $   dBP @
+$dBBBBP  @
+         @@
+  $dBP dBP@
+ $    dBP @
+$dBBBBBP  @
+    dBP   @
+   dBP    @
+          @@
+    $dBBBBBP@
+   $        @
+  $dBBBBBP  @
+ $    dBP   @
+$dBBBBBP    @
+            @@
+   $dBBBBP@
+  $dP     @
+ $dP dBP  @
+$dP  dP   @
+$VBBBP    @
+          @@
+$dBBBBb @
+        @
+  $dBP  @
+ $dBP   @
+$dBP    @
+        @@
+    $dBBBb@
+   $dP  dP@
+  $dPBBBP @
+ $dP  dP  @
+$ VBBBP   @
+          @@
+   $dBBBBb@
+  $dP  dBP@
+  $VBBBBP @
+ $    dP  @
+$ dBBBP   @
+          @@
+    $ @
+   $  @
+  $dBP@
+ $    @
+$dBP  @
+      @@
+$     @
+$     @
+$  dBP@
+$     @
+$ dBP @
+$dBP  @@
+     @
+$ dP @
+$dP  @
+$Vb  @
+$ Vb @
+     @@
+        @
+  $dBBBP@
+ $      @
+$dBBBP  @
+        @
+        @@
+     @
+$Vb  @
+$`Bb @
+$ dP @
+$dP  @
+     @@
+$dBBBBb@
+$Vb dBP@
+   dBP @
+       @
+$dBP   @
+       @@
+   $       @
+  $dBBBBBBb@
+ $dBP _  dB@
+$dBP  " dB'@
+$VBBBBBBB' @
+           @@
+ $dBBBBBb @
+   $   BB @
+  $dBP BB @
+ $dBP  BB @
+$dBBBBBBB @
+          @@
+   $dBBBBb@
+   $   dBP@
+  $dBBBK' @
+ $dB' db  @
+$dBBBBP'  @
+          @@
+    $dBBBP@
+   $      @
+  $dBP    @
+ $dBP     @
+$dBBBBP   @
+          @@
+    $dBBBBb@
+   $    dB'@
+  $dBP dB' @
+ $dBP dB'  @
+$dBBBBB'   @
+           @@
+    $dBBBP @
+   $       @
+  $dBBP    @
+ $dBP      @
+$dBBBBP    @
+           @@
+    $dBBBBP@
+   $       @
+  $dBBBP   @
+ $dBP      @
+$dBP       @
+           @@
+    $dBBBBb@
+   $       @
+  $dBBBB   @
+ $dB' BB   @
+$dBBBBBB   @
+           @@
+    $dBP dBP@
+            @
+  $dBBBBBP  @
+ $dBP dBP   @
+$dBP dBP    @
+            @@
+    $dBP@
+   $    @
+  $dBP  @
+ $dBP   @
+$dBP    @
+        @@
+        dBP@
+           @
+      dBP  @
+ $dB'dBP   @
+$dBBBBP    @
+           @@
+   $ dBP dBP@
+    dBP.d8P @
+  $dBBBBP'  @
+ $dBP BB    @
+$dBP dB'    @
+            @@
+    $dBP@
+   $    @
+  $dBP  @
+ $dBP   @
+$dBBBBP @
+        @@
+     $dBBBBBBb@
+    $  '   dB'@
+   $dB'dB'dB' @
+  $dB'dB'dB'  @
+ $dB'dB'dB'   @
+              @@
+    $dBBBBb@
+   $    dBP@
+  $dBP dBP @
+ $dBP dBP  @
+$dBP dBP   @
+           @@
+    $dBBBBP@
+   $dB'.BP @
+  $dB'.BP  @
+ $dB'.BP   @
+$dBBBBP    @
+           @@
+  $dBBBBBb@
+  $    dB'@
+  $dBBBP' @
+ $dBP     @
+$dBP      @
+          @@
+    $dBBBBP@
+   $dB'.BP @
+  $dB'.BP  @
+ $dB'.BB   @
+$dBBBB'B   @
+           @@
+  $dBBBBBb@
+  $    dBP@
+  $dBBBBK'@
+ $dBP  BB @
+$dBP  dB' @
+          @@
+  .dBBBBP@
+  BP     @
+  `BBBBb @
+     dBP @
+dBBBBP'  @
+         @@
+$ dBBBBBBP@
+          @
+  $dBP    @
+ $dBP     @
+$dBP      @
+          @@
+    $dBP dBP@
+   $        @
+  $dBP dBP  @
+ $dBP_dBP   @
+$dBBBBBP    @
+            @@
+  dBP dP@
+        @
+$dB .BP @
+ BB.BP  @
+ BBBP   @
+        @@
+    $dBPdBPdBP@
+   $          @
+  $dBPdBPdBP  @
+ $dBPdBPdBP   @
+$dBBBBBBBP    @
+              @@
+$`Bb  .BP@
+ $   .BP @
+  $dBBK  @
+ $dB'    @
+$dB' dBP @
+         @@
+$dBP dBP@
+   $dBP @
+  $dBP  @
+ $dBP   @
+$dBP    @
+        @@
+$dBBBBBP@
+        @
+  $dBP  @
+ $dBP   @
+$dBBBBP @
+        @@
+     $dBBb $@
+    $dBP  $ @
+   $dBP  $  @
+  $dBP  $   @
+ $dBP  $    @
+$dBBBP$     @@
+       @
+`Bb    @
+ `Bb   @
+  `Bb  @
+   `Bb$@
+       @@
+     $dBBP$@
+    $ dBP$ @
+   $ dBP$  @
+  $ dBP$   @
+ $ dBP$    @
+$VBBP$     @@
+ $dBb @
+$dP`Bb@
+      @
+      @
+      @
+      @@
+     $$$@
+    $$$$@
+   $$$$$@
+  $$$$$$@
+ $$$$$$$@
+$dBBBBBP@@
+    @
+$dBb@
+$`BP@
+$ ' @
+    @
+    @@
+ $dBBBBBb@
+       BB@
+  $dBP BB@
+ $dBP  BB@
+$dBBBBBBB@
+         @@
+   $dBBBBb@
+   $   dBP@
+  $dBBBK' @
+ $dB' db  @
+$dBBBBP'  @
+          @@
+    $dBBBP@
+   $      @
+  $dBP    @
+ $dBP     @
+$dBBBBP   @
+          @@
+    $dBBBBb@
+   $    dBP@
+  $dBP dBP @
+ $dBP dBP  @
+$dBBBBBP   @
+           @@
+    $dBBBP @
+   $       @
+  $dBBP    @
+ $dBP      @
+$dBBBBP    @
+           @@
+    $dBBBBP@
+   $       @
+  $dBBBP   @
+ $dBP      @
+$dBP       @
+           @@
+    $dBBBBb@
+   $       @
+  $dBBBB   @
+ $dB' BB   @
+$dBBBBBB   @
+           @@
+    $dBP dBP@
+   $        @
+  $dBBBBBP  @
+ $dBP dBP   @
+$dBP dBP    @
+            @@
+    $dBP@
+   $    @
+  $dBP  @
+ $dBP   @
+$dBP    @
+        @@
+        dBP@
+           @
+      dBP  @
+ $dB'dBP   @
+$dBBBBP    @
+           @@
+    $dBP dBP@
+   $d8P.dBP @
+  $dBBBBP   @
+ $dBP BB    @
+$dBP dBP    @
+            @@
+    $dBP@
+   $    @
+  $dBP  @
+ $dBP   @
+$dBBBBP @
+        @@
+    $dBBBBBBb@
+   $      dBP@
+  $dBPdBPdBP @
+ $dBPdBPdBP  @
+$dBPdBPdBP   @
+             @@
+    $dBBBBb@
+   $    dBP@
+  $dBP dBP @
+ $dBP dBP  @
+$dBP dBP   @
+           @@
+    $dBBBBP@
+   $dBP.BP @
+  $dBP.BP  @
+ $dBP.BP   @
+$dBBBBP    @
+           @@
+  $dBBBBBb@
+  $    dB'@
+  $dBBBP' @
+ $dBP     @
+$dBP      @
+          @@
+    $dBBBBP@
+   $dBP.BP @
+  $dBP.BP  @
+ $dBP.BB   @
+$dBBBB'B   @
+           @@
+  $dBBBBBb@
+  $    dBP@
+  $dBBBBK @
+ $dBP  BB @
+$dBP  dB' @
+          @@
+  .dBBBBP@
+  BP     @
+  `BBBBb @
+     dBP @
+dBBBBP'  @
+         @@
+ $dBBBBBBP@
+          @
+  $dBP    @
+ $dBP     @
+$dBP      @
+          @@
+    $dBP dBP@
+   $        @
+  $dBP dBP  @
+ $dBP_dBP   @
+$dBBBBBP    @
+            @@
+   dBP dP@
+         @
+$dB .BP  @
+ BB.BP   @
+ BBBP    @
+         @@
+    $dBPdBPdBP@
+   $          @
+  $dBPdBPdBP  @
+ $dBPdBPdBP   @
+$dBBBBBBBP    @
+              @@
+`Bb  .BP@
+    .BP @
+  dBBK  @
+ dB'    @
+dB' dBP @
+        @@
+$dBP dBP@
+    dBP @
+   dBP  @
+  dBP   @
+ dBP    @
+        @@
+$dBBBBBP@
+        @
+  $dBP  @
+ $dBP   @
+$dBBBBP @
+        @@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@@

.pnpm-store/v11/files/5d/f5834d1df3a97531dd6cd2703519856b7b1538a9e49a4ed2bad4adbec81b83f286a11e83de334dd1efbf12a886d3287488474e6eefabcada9a39cb6b898796

@@ -0,0 +1 @@
+module.exports={C:{"11":0.01451,"52":0.00967,"78":0.00967,"115":0.14027,"120":0.04837,"121":0.09674,"123":0.01451,"124":0.02419,"125":0.00967,"128":0.00484,"132":0.00484,"133":0.00484,"134":0.00484,"135":0.00484,"136":0.00967,"139":0.00484,"140":0.08707,"142":0.00484,"143":0.00484,"146":0.00484,"147":0.00967,"148":0.01451,"149":0.00967,"150":0.01451,"151":0.01451,"152":0.03386,"153":0.07739,"154":0.26604,"155":0.84648,"156":0.75457,"157":0.02902,_:"2 3 4 5 6 7 8 9 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 116 117 118 119 122 126 127 129 130 131 137 138 141 144 145 158 159 160 3.5 3.6"},D:{"48":0.01451,"49":0.00967,"70":0.00967,"74":0.02419,"77":0.00484,"80":0.00484,"87":0.00967,"93":0.01451,"101":0.00484,"102":0.01451,"103":0.13544,"104":0.05321,"105":0.05321,"106":0.05321,"107":0.05321,"108":0.05321,"109":0.30957,"110":0.05321,"111":0.05804,"112":0.05804,"114":0.00967,"115":0.00484,"116":0.17897,"117":0.05321,"118":0.0919,"119":0.10641,"120":0.16446,"121":0.01451,"122":0.04837,"123":0.02902,"124":0.08223,"125":0.22734,"126":0.04837,"127":0.03386,"128":0.08223,"129":0.00967,"130":0.02902,"131":0.21767,"132":0.02419,"133":0.13544,"134":0.04353,"135":0.04353,"136":0.653,"137":0.05804,"138":0.23218,"139":0.05321,"140":0.06288,"141":0.05804,"142":0.48854,"143":0.08223,"144":0.40631,"145":0.08223,"146":0.66267,"147":0.44984,"148":0.35794,"149":0.3918,"150":1.08349,"151":4.21786,"152":8.95812,"153":5.92533,"154":1.36887,"155":0.01935,_:"4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 71 72 73 75 76 78 79 81 83 84 85 86 88 89 90 91 92 94 95 96 97 98 99 100 113 156 157"},F:{"95":0.02419,"101":0.01451,"105":0.00967,"106":0.02419,"107":0.00967,"114":0.00484,"115":0.00484,"116":0.00484,"120":0.00484,"121":0.00484,"122":0.00484,"133":0.00967,"134":0.10158,"135":0.46435,_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 96 97 98 99 100 102 103 104 108 109 110 111 112 113 117 118 119 123 124 125 126 127 131 132 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"109":0.04353,"119":0.04837,"120":0.04837,"122":0.01935,"123":0.00484,"124":0.00484,"131":0.00484,"132":0.00967,"133":0.00484,"134":0.00484,"135":0.00484,"138":0.00967,"139":0.00967,"140":0.00967,"141":0.00967,"142":0.00967,"143":0.00967,"144":0.00967,"145":0.00967,"146":0.01451,"147":0.01451,"148":0.01935,"149":0.02419,"150":0.14995,"151":0.34826,"152":2.4572,"153":3.09568,"154":0.76908,_:"12 13 14 15 16 17 18 79 80 81 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 110 111 112 113 114 115 116 117 118 121 125 126 127 128 129 130 136 137"},E:{"14":0.01451,"27":0.20799,_:"4 5 6 7 8 9 10 11 12 13 15 3.1 3.2 5.1 6.1 7.1 9.1 10.1 11.1 15.1 15.2-15.3 27.1 TP","12.1":0.00484,"13.1":0.03386,"14.1":0.02902,"15.4":0.00484,"15.5":0.00484,"15.6":0.12576,"16.0":0.00484,"16.1":0.01451,"16.2":0.00967,"16.3":0.01935,"16.4":0.00967,"16.5":0.02419,"16.6":0.29506,"17.0":0.01935,"17.1":0.2225,"17.2":0.02902,"17.3":0.0387,"17.4":0.17413,"17.5":0.12093,"17.6":0.51756,"18.0":0.01451,"18.1":0.11125,"18.2":0.01451,"18.3":0.06288,"18.4":0.01935,"18.5-18.7":0.05321,"26.0":0.02419,"26.1":0.02419,"26.2":0.09674,"26.3":0.1306,"26.4":0.1306,"26.5":0.52723,"26.6":3.09084,"27.2":0.00484},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0,"5.0-5.1":0,"6.0-6.1":0,"7.0-7.1":0,"8.1-8.4":0,"9.0-9.2":0,"9.3":0,"10.0-10.2":0,"10.3":0.0142,"11.0-11.2":0,"11.3-11.4":0.00473,"12.0-12.1":0.00237,"12.2-12.5":0.04259,"13.0-13.1":0,"13.2":0.0142,"13.3":0,"13.4-13.7":0,"14.0-14.4":0.01183,"14.5-14.8":0.0142,"15.0-15.1":0.01183,"15.2-15.3":0.0071,"15.4":0.0071,"15.5":0.00947,"15.6-15.8":0.15381,"16.0":0.00947,"16.1":0.0213,"16.2":0.01183,"16.3":0.02366,"16.4":0.00947,"16.5":0.00947,"16.6-16.7":0.26029,"17.0":0.0071,"17.1":0.0142,"17.2":0.01893,"17.3":0.02603,"17.4":0.0284,"17.5":0.05916,"17.6-17.7":0.1964,"18.0":0.02366,"18.1":0.06862,"18.2":0.09465,"18.3":0.17274,"18.4":0.10412,"18.5-18.7":3.05484,"26.0":0.07809,"26.1":0.09228,"26.2":0.27449,"26.3":0.33838,"26.4":0.2177,"26.5":1.72974,"26.6":15.46588,"27.0":0.75957,"27.1":0,"27.2":0.0284},P:{"21":0.00981,"22":0.00981,"23":0.00981,"24":0.00981,"25":0.00981,"26":0.02943,"27":0.01962,"28":0.06868,"29":0.0883,"30":1.42257,_:"4 20 5.0-5.4 6.2-6.4 7.2-7.4 8.2 9.2 10.1 11.1-11.2 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0"},I:{"0":0.02063,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0,"4.4":0,"4.4.3-4.4.4":0.00001},K:{"0":0.32521,_Line truncated

.pnpm-store/v11/files/5d/f67e7fb53121ac2615f77b30a191212698c7986e19995895eff6a0ac206deea9c44820f05806422e1a000f73a50e8541abd8a448fe8d383fb405e4b66830d1

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","names":[],"sources":["../../src/route.ts"],"sourcesContent":["import { invariant } from './invariant'\nimport { joinPaths, trimPathLeft, trimPathRight } from './path'\nimport { notFound } from './not-found'\nimport { redirect } from './redirect'\nimport { rootRouteId } from './root'\nimport type { LazyRoute } from './fileRoute'\nimport type { NotFoundError } from './not-found'\nimport type { RedirectFnRoute } from './redirect'\nimport type { NavigateOptions, ParsePathParams } from './link'\nimport type { ParsedLocation } from './location'\nimport type {\n  AnyRouteMatch,\n  MakePreValidationErrorHandlingRouteMatchUnion,\n  MakeRouteMatchFromRoute,\n  MakeRouteMatchUnion,\n  RouteMatch,\n} from './Matches'\nimport type { RootRouteId } from './root'\nimport type { ParseRoute, RouteById, RouteIds, RoutePaths } from './routeInfo'\nimport type { AnyRouter, Register, RegisteredRouter, SSROption } from './router'\nimport type { BuildLocationFn, NavigateFn } from './RouterProvider'\nimport type {\n  Assign,\n  Awaitable,\n  Constrain,\n  Expand,\n  IntersectAssign,\n  LooseAsyncReturnType,\n  LooseReturnType,\n  NoInfer,\n} from './utils'\nimport type {\n  AnySchema,\n  AnyStandardSchemaValidator,\n  AnyValidator,\n  AnyValidatorAdapter,\n  AnyValidatorObj,\n  DefaultValidator,\n  ResolveSearchValidatorInput,\n  ResolveValidatorOutput,\n  StandardSchemaValidator,\n  ValidatorAdapter,\n  ValidatorFn,\n  ValidatorObj,\n} from './validators'\nimport type { ValidateSerializableLifecycleResult } from './ssr/serializer/transformer'\n\nexport type AnyPathParams = {}\n\nexport type SearchSchemaInput = {\n  __TSearchSchemaInput__: 'TSearchSchemaInput'\n}\n\nexport type AnyContext = {}\n\nexport interface RouteContext {}\n\nexport type PreloadableObj = { preload?: () => Promise<void> }\n\nexport type RoutePathOptions<TCustomId, TPath> =\n  | {\n      path: TPath\n    }\n  | {\n      id: TCustomId\n    }\n\nexport interface StaticDataRouteOption {}\n\nexport type RoutePathOptionsIntersection<TCustomId, TPath> = {\n  path: TPath\n  id: TCustomId\n}\n\nexport type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult\n\nexport type SearchMiddlewareContext<TSearchSchema> = {\n  search: TSearchSchema\n  next: (newSearch: TSearchSchema) => TSearchSchema\n}\n\nexport type SearchMiddleware<TSearchSchema> = (\n  ctx: SearchMiddlewareContext<TSearchSchema>,\n) => TSearchSchema\n\nexport type ResolveId<\n  TParentRoute,\n  TCustomId extends string,\n  TPath extends string,\n> = TParentRoute extends { id: infer TParentId extends string }\n  ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId>\n  : RootRouteId\n\nexport type InferFullSearchSchema<TRoute> = TRoute extends {\n  types: {\n    fullSearchSchema: infer TFullSearchSchema\n  }\n}\n  ? TFullSearchSchema\n  : {}\n\nexport type InferFullSearchSchemaInput<TRoute> = TRoute extends {\n  types: {\n    fullSearchSchemaInput: infer TFullSearchSchemaInput\n  }\n}\n  ? TFullSearchSchemaInput\n  : {}\n\nexport type InferAllParams<TRoute> = TRoute extends {\n  types: {\n    allParams: infer TAllParams\n  }\n}\n  ? TAllParams\n  : {}\n\nexport type InferAllContext<TRoute> = unknown extends TRoute\n  ? TRoute\n  : TRoute extends {\n        types: {\n          allContext: infer TAllContext\n        }\n      }\n    ? TAllContext\n    : {}\n\nexport type ResolveSearchSchemaFnInput<TSearchValidator> =\n  TSearchValidator extends (input: infer TSearchSchemaInput) => any\n    ? TSearchSchemaInput extends SearchSchemaInput\n      ? Omit<TSearchSchemaInput, keyof SearchSchemaInput>\n      : ResolveSearchSchemaFn<TSearchValidator>\n    : AnySchema\n\nexport type ResolveSearchSchemaInput<TSearchValidator> =\n  TSearchValidator extends AnyStandardSchemaValidator\n    ? NonNullable<TSearchValidator['~standard']['types']>['input']\n    : TSearchValidator extends AnyValidatorAdapter\n      ? TSearchValidator['types']['input']\n      : TSearchValidator extends AnyValidatorObj\n        ? ResolveSearchSchemaFnInput<TSearchValidator['parse']>\n        : ResolveSearchSchemaFnInput<TSearchValidator>\n\nexport type ResolveSearchSchemaFn<TSearchValidator> = TSearchValidator extends (\n  ...args: any\n) => infer TSearchSchema\n  ? TSearchSchema\n  : AnySchema\n\nexport type ResolveSearchSchema<TSearchValidator> =\n  unknown extends TSearchValidator\n    ? TSearchValidator\n    : TSearchValidator extends AnyStandardSchemaValidator\n      ? NonNullable<TSearchValidator['~standard']['types']>['output']\n      : TSearchValidator extends AnyValidatorAdapter\n        ? TSearchValidator['types']['output']\n        : TSearchValidator extends AnyValidatorObj\n          ? ResolveSearchSchemaFn<TSearchValidator['parse']>\n          : ResolveSearchSchemaFn<TSearchValidator>\n\nexport type ResolveRequiredParams<TPath extends string, T> = {\n  [K in ParsePathParams<TPath>['required']]: T\n}\n\nexport type ResolveOptionalParams<TPath extends string, T> = {\n  [K in PaLine truncated

.pnpm-store/v11/files/5d/fb78a7992d8d41d0040b19f7f27cd9586d8a383c8f3aa16ee31b9cc65868dae9fe4d9a5b450b9f80c2a94ba5b6362eef9ab8b3e262c47dc8a6df6a5ea7eb03

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { Primitive } from '@radix-ui/react-primitive';
+
+declare const VISUALLY_HIDDEN_STYLES: Readonly<{
+    position: "absolute";
+    border: 0;
+    width: 1;
+    height: 1;
+    padding: 0;
+    margin: -1;
+    overflow: "hidden";
+    clip: "rect(0, 0, 0, 0)";
+    whiteSpace: "nowrap";
+    wordWrap: "normal";
+}>;
+type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
+interface VisuallyHiddenProps extends PrimitiveSpanProps {
+}
+declare const VisuallyHidden: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Root: React.ForwardRefExoticComponent<VisuallyHiddenProps & React.RefAttributes<HTMLSpanElement>>;
+
+export { Root, VISUALLY_HIDDEN_STYLES, VisuallyHidden, type VisuallyHiddenProps };