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

.pnpm-store/v3/files/b4/031c1a1ead91514077e92bbfc33b9d7d21f01dc55b3cd79fc0dbb71b0d31ee6a466ec3b2970de0c57a8d5a5f81c95670812799624ddca1e32f8d22e50d203a

@@ -0,0 +1,10 @@
+import { PluginFunc } from 'dayjs/esm'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs/esm' {
+  interface Dayjs {
+    isLeapYear(): boolean
+  }
+}

.pnpm-store/v3/files/b4/0379c355b735084e22d2d363b1b48177b89fde4a8a44dc72210b0563d342ff30469c0d56089390c655b10743088793f2304bcb815e5860fba4aa96c21c4023

@@ -0,0 +1,41 @@
+{
+  "name": "tar-fs",
+  "version": "2.1.4",
+  "description": "filesystem bindings for tar-stream",
+  "dependencies": {
+    "chownr": "^1.1.1",
+    "mkdirp-classic": "^0.5.2",
+    "pump": "^3.0.0",
+    "tar-stream": "^2.1.4"
+  },
+  "keywords": [
+    "tar",
+    "fs",
+    "file",
+    "tarball",
+    "directory",
+    "stream"
+  ],
+  "devDependencies": {
+    "rimraf": "^2.6.3",
+    "standard": "^13.0.1",
+    "tape": "^4.9.2"
+  },
+  "scripts": {
+    "test": "standard && tape test/index.js"
+  },
+  "bugs": {
+    "url": "https://github.com/mafintosh/tar-fs/issues"
+  },
+  "homepage": "https://github.com/mafintosh/tar-fs",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "author": "Mathias Buus",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/tar-fs.git"
+  }
+}

.pnpm-store/v3/files/b4/0a4fb31489d559fb0cc4c4d6e2421dcf411393964b85eeddb18e82d5a4613b306ea8f5af89c195de5b99d185da86fb16287826145d606d1bcd67f083f774a4

@@ -0,0 +1,24 @@
+var arrayMap = require('./_arrayMap'),
+    createOver = require('./_createOver');
+
+/**
+ * Creates a function that invokes `iteratees` with the arguments it receives
+ * and returns their results.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Util
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ *  The iteratees to invoke.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var func = _.over([Math.max, Math.min]);
+ *
+ * func(1, 2, 3, 4);
+ * // => [4, 1]
+ */
+var over = createOver(arrayMap);
+
+module.exports = over;

.pnpm-store/v3/files/b4/0b320d1c42d6db772c542a52d49d82341da4789561c977dab76d25befd7e8bb335b5a46c6c0de41304568157e81d8fedd972f963f309783b422e13a4c598f3

@@ -0,0 +1,121 @@
+{
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "bugs": "https://github.com/wooorm/property-information/issues",
+  "contributors": [
+    "Andrew Burgess <andrew@andrewburgess.io>",
+    "Dustin Deus <deusdustin@gmail.com> (http://starptech.de)",
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "description": "Info on the properties and attributes of the web platform",
+  "devDependencies": {
+    "@types/mdast": "^4.0.0",
+    "@types/node": "^22.0.0",
+    "alpha-sort": "^5.0.0",
+    "c8": "^10.0.0",
+    "html-element-attributes": "^3.0.0",
+    "html-event-attributes": "^2.0.0",
+    "mdast-zone": "^6.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-preset-wooorm": "^11.0.0",
+    "svg-element-attributes": "^2.0.0",
+    "svg-event-attributes": "^2.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "unist-builder": "^4.0.0",
+    "xo": "^0.60.0"
+  },
+  "exports": "./index.js",
+  "files": [
+    "index.d.ts",
+    "index.js",
+    "lib/"
+  ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/wooorm"
+  },
+  "keywords": [
+    "aria",
+    "attribute",
+    "html",
+    "information",
+    "info",
+    "property",
+    "svg"
+  ],
+  "license": "MIT",
+  "name": "property-information",
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm",
+      "./script/list.js"
+    ]
+  },
+  "repository": "wooorm/property-information",
+  "scripts": {
+    "build": "tsc --build --clean && tsc --build && type-coverage",
+    "format": "remark --frail --output --quiet -- . && prettier --log-level warn --write -- . && xo --fix",
+    "generate": "node --conditions development script/generate-react.js && node --conditions development script/generate-exceptions.js",
+    "test-api": "node --conditions development test.js",
+    "test-coverage": "c8 --100 --reporter lcov -- npm run test-api",
+    "test": "npm run generate && npm run build && npm run format && npm run test-coverage"
+  },
+  "sideEffects": false,
+  "typeCoverage": {
+    "atLeast": 100,
+    "ignoreCatch": true
+  },
+  "type": "module",
+  "version": "7.1.0",
+  "xo": {
+    "overrides": [
+      {
+        "files": [
+          "script/**/*.js",
+          "test.js"
+        ],
+        "rules": {
+          "no-await-in-loop": "off"
+        }
+      },
+      {
+        "files": [
+          "**/*.d.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/array-type": [
+            "error",
+            {
+              "default": "generic"
+            }
+          ],
+          "@typescript-eslint/ban-types": [
+            "error",
+            {
+              "extendDefaults": true
+            }
+          ],
+          "@typescript-eslint/consistent-type-definitions": [
+            "error",
+            "interface"
+          ]
+        }
+      }
+    ],
+    "prettier": true,
+    "rules": {
+      "logical-assignment-operators": "off",
+      "no-bitwise": "off",
+      "unicorn/prefer-string-replace-all": "off"
+    }
+  }
+}

.pnpm-store/v3/files/b4/0b41b471d36b5828cb9d89f6588097b14ea1d73c40bdd96196ae1f7f4fa9d78de41286b30842f8ddf12da1a2c0725b6dbe82aa094e4ddb56bc26b2991610cb

@@ -0,0 +1,36 @@
+import Inline from '../blots/inline.js';
+class Link extends Inline {
+  static blotName = 'link';
+  static tagName = 'A';
+  static SANITIZED_URL = 'about:blank';
+  static PROTOCOL_WHITELIST = ['http', 'https', 'mailto', 'tel', 'sms'];
+  static create(value) {
+    const node = super.create(value);
+    node.setAttribute('href', this.sanitize(value));
+    node.setAttribute('rel', 'noopener noreferrer');
+    node.setAttribute('target', '_blank');
+    return node;
+  }
+  static formats(domNode) {
+    return domNode.getAttribute('href');
+  }
+  static sanitize(url) {
+    return sanitize(url, this.PROTOCOL_WHITELIST) ? url : this.SANITIZED_URL;
+  }
+  format(name, value) {
+    if (name !== this.statics.blotName || !value) {
+      super.format(name, value);
+    } else {
+      // @ts-expect-error
+      this.domNode.setAttribute('href', this.constructor.sanitize(value));
+    }
+  }
+}
+function sanitize(url, protocols) {
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  const protocol = anchor.href.slice(0, anchor.href.indexOf(':'));
+  return protocols.indexOf(protocol) > -1;
+}
+export { Link as default, sanitize };
+//# sourceMappingURL=link.js.map

.pnpm-store/v3/files/b4/0da642c921ed6b125287bcf60c31f03adeb39d45fe7655e999f979a15f4815569cd7c95a046a0bbfc6c809ebdbe625512db53cc85c99f459565a188adbed0a

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=BaseBindingNode.js.map

.pnpm-store/v3/files/b4/1110fefdfb4fc4eb68321da30c8018d9d8f3960d01c6de60b40274eba55eaadefdebb449fe2f5a4137ac11285a9ff618634f3bfd3bd156b7bd3ee8db4c4368

@@ -0,0 +1,144 @@
+import { __assign, __awaiter, __generator, __read, __rest, __spreadArray } from "tslib";
+import { isFunction } from '../../utils';
+var Fetch = /** @class */ (function () {
+    function Fetch(serviceRef, options, subscribe, initState) {
+        if (initState === void 0) { initState = {}; }
+        this.serviceRef = serviceRef;
+        this.options = options;
+        this.subscribe = subscribe;
+        this.initState = initState;
+        this.pluginImpls = [];
+        this.count = 0;
+        this.state = {
+            loading: false,
+            params: undefined,
+            data: undefined,
+            error: undefined,
+        };
+        this.state = __assign(__assign(__assign({}, this.state), { loading: !options.manual }), initState);
+    }
+    Fetch.prototype.setState = function (s) {
+        if (s === void 0) { s = {}; }
+        this.state = __assign(__assign({}, this.state), s);
+        this.subscribe();
+    };
+    Fetch.prototype.runPluginHandler = function (event) {
+        var rest = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            rest[_i - 1] = arguments[_i];
+        }
+        // @ts-ignore
+        var r = this.pluginImpls.map(function (i) { var _a; return (_a = i[event]) === null || _a === void 0 ? void 0 : _a.call.apply(_a, __spreadArray([i], __read(rest), false)); }).filter(Boolean);
+        return Object.assign.apply(Object, __spreadArray([{}], __read(r), false));
+    };
+    Fetch.prototype.runAsync = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var currentCount, _a, _b, stopNow, _c, returnNow, state, servicePromise, res, error_1;
+            var _d;
+            var _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            return __generator(this, function (_q) {
+                switch (_q.label) {
+                    case 0:
+                        this.count += 1;
+                        currentCount = this.count;
+                        _a = this.runPluginHandler('onBefore', params), _b = _a.stopNow, stopNow = _b === void 0 ? false : _b, _c = _a.returnNow, returnNow = _c === void 0 ? false : _c, state = __rest(_a, ["stopNow", "returnNow"]);
+                        // stop request
+                        if (stopNow) {
+                            return [2 /*return*/, new Promise(function () { })];
+                        }
+                        this.setState(__assign({ loading: true, params: params }, state));
+                        // return now
+                        if (returnNow) {
+                            return [2 /*return*/, Promise.resolve(state.data)];
+                        }
+                        (_f = (_e = this.options).onBefore) === null || _f === void 0 ? void 0 : _f.call(_e, params);
+                        _q.label = 1;
+                    case 1:
+                        _q.trys.push([1, 3, , 4]);
+                        servicePromise = this.runPluginHandler('onRequest', this.serviceRef.current, params).servicePromise;
+                        if (!servicePromise) {
+                            servicePromise = (_d = this.serviceRef).current.apply(_d, __spreadArray([], __read(params), false));
+                        }
+                        return [4 /*yield*/, servicePromise];
+                    case 2:
+                        res = _q.sent();
+                        if (currentCount !== this.count) {
+                            // prevent run.then when request is canceled
+                            return [2 /*return*/, new Promise(function () { })];
+                        }
+                        // const formattedResult = this.options.formatResultRef.current ? this.options.formatResultRef.current(res) : res;
+                        this.setState({
+                            data: res,
+                            error: undefined,
+                            loading: false,
+                        });
+                        (_h = (_g = this.options).onSuccess) === null || _h === void 0 ? void 0 : _h.call(_g, res, params);
+                        this.runPluginHandler('onSuccess', res, params);
+                        (_k = (_j = this.options).onFinally) === null || _k === void 0 ? void 0 : _k.call(_j, params, res, undefined);
+                        if (currentCount === this.count) {
+                            this.runPluginHandler('onFinally', params, res, undefined);
+                        }
+                        return [2 /*return*/, res];
+                    case 3:
+                        error_1 = _q.sent();
+                        if (currentCount !== this.count) {
+                            // prevent run.then when request is canceled
+                            return [2 /*return*/, new Promise(function () { })];
+                        }
+                        this.setState({
+                            error: error_1,
+                            loading: false,
+                        });
+                        (_m = (_l = this.options).onError) === null || _m === void 0 ? void 0 : _m.call(_l, error_1, params);
+                        this.runPluginHandler('onError', error_1, params);
+                        (_p = (_o = this.options).onFinally) === null || _p === void 0 ? void 0 : _p.call(_o, params, undefined, error_1);
+                        if (currentCount === this.count) {
+                            this.runPluginHandler('onFinally', params, undefined, error_1);
+                        }
+                        throw error_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Fetch.prototype.run = function () {
+        var _this = this;
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        this.runAsync.apply(this, __spreadArray([], __read(params), false)).catch(function (error) {
+            if (!_this.options.onError) {
+                console.error(error);
+            }
+        });
+    };
+    Fetch.prototype.cancel = function () {
+        this.count += 1;
+        this.setState({
+            loading: false,
+        });
+        this.runPluginHandler('onCancel');
+    };
+    Fetch.prototype.refresh = function () {
+        // @ts-ignore
+        this.run.apply(this, __spreadArray([], __read((this.state.params || [])), false));
+    };
+    Fetch.prototype.refreshAsync = function () {
+        // @ts-ignore
+        return this.runAsync.apply(this, __spreadArray([], __read((this.state.params || [])), false));
+    };
+    Fetch.prototype.mutate = function (data) {
+        var targetData = isFunction(data) ? data(this.state.data) : data;
+        this.runPluginHandler('onMutate', targetData);
+        this.setState({
+            data: targetData,
+        });
+    };
+    return Fetch;
+}());
+export default Fetch;

.pnpm-store/v3/files/b4/1171069f4d7f2cb9aec99e7cdf965dcd49796fe3d81a411c574b65b1157ecf709f7137351171c15d29260f0cd6a4007b1169bf3ef78495c5a1f574640bbdd8-index.json

@@ -0,0 +1 @@
+{"name":"@types/react","version":"19.2.4","requiresBuild":false,"files":{"LICENSE":{"checkedAt":1794532108358,"integrity":"sha512-HQaIQk9pwOcyKutyDk4o2a87WnotwYuLGYFW43emGm4FvIJFKPyg+OYaw5sTegKAKf+C5SKa1ACjzCLivbaHrQ==","mode":420,"size":1141},"README.md":{"checkedAt":1794532108358,"integrity":"sha512-itJIxR86CF9ZRNST5Cmvj4jelkXzhlrRB7YaxdvegDsiGWgUGDv+phiu8RXG62qAVMf6+9bbisrHoo08Ip81CA==","mode":420,"size":1750},"canary.d.ts":{"checkedAt":1794532108358,"integrity":"sha512-1p3macNnv0fH7sZ/rnwSWrbGgPEdiYAdL/n3Lj/K5RnZEJiifdzl7u9WrmRMayalSgl4SmDt51dWhDMPWHaYcw==","mode":420,"size":5981},"compiler-runtime.d.ts":{"checkedAt":1794532108358,"integrity":"sha512-PElVyYQ84mJw6nIXcq6JkFPmTXyCpgWau9UtzdoOrN8PZ6NGoBDygoyS0d980ysvN9zzticywCDeMS4wT6X2Ig==","mode":420,"size":116},"experimental.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-aivSufOK5LYuPBYnyM0QuTal4rPJ99CiOu6yKJSXspRmo/GLCQL6XzFOUuC/DOcwtoU3+6d93NGDnqMbyuOIlA==","mode":420,"size":5976},"global.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-CvcPpXjx51aF8tg1G6B/CNpmzm/1lVDk17MeottCsvxKqrAEosc2WLSYM5OXnInybZjRA3zx9K+knsYAZXCwLQ==","mode":420,"size":7481},"index.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-gIzed0WJgFvLW5lfDPKsjhRoa1S42A0ok+/VX/cZtlc5YtBs1OPlZnN3srUOWQPncT+Vpc3RcQIZiFByN+sOMw==","mode":420,"size":174475},"jsx-dev-runtime.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-DBVUfYDh/2CaI+DzGlmhmCc0/xm31M4ZV7TVuQcPeZA1aSiIaO0wEaDqtZy2gJbLGs1czvbhuS//OMItBm0raA==","mode":420,"size":1412},"jsx-runtime.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-JSUY0WOLmNHE08AfaK5KX93jONEL331mRTx0h2KORY/5t+DOers7AlahHGSVu8iItfzS2B78H+b6HB9RbtnPDA==","mode":420,"size":1204},"package.json":{"checkedAt":1794532108360,"integrity":"sha512-WvcNF27UxnW3Bzu5/V9Q350Hff72yRnx1OuUF9FmqK0YEHmrNtMB5K0jOO61GuCQhC9VUfRx++1P5vA4XTKBvA==","mode":420,"size":6108},"ts5.0/canary.d.ts":{"checkedAt":1794532108358,"integrity":"sha512-1p3macNnv0fH7sZ/rnwSWrbGgPEdiYAdL/n3Lj/K5RnZEJiifdzl7u9WrmRMayalSgl4SmDt51dWhDMPWHaYcw==","mode":420,"size":5981},"ts5.0/experimental.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-aivSufOK5LYuPBYnyM0QuTal4rPJ99CiOu6yKJSXspRmo/GLCQL6XzFOUuC/DOcwtoU3+6d93NGDnqMbyuOIlA==","mode":420,"size":5976},"ts5.0/global.d.ts":{"checkedAt":1794532108359,"integrity":"sha512-CvcPpXjx51aF8tg1G6B/CNpmzm/1lVDk17MeottCsvxKqrAEosc2WLSYM5OXnInybZjRA3zx9K+knsYAZXCwLQ==","mode":420,"size":7481},"ts5.0/index.d.ts":{"checkedAt":1794532108360,"integrity":"sha512-HIK2PyVLgT9cgf1UswxouI18IRLhLz1Tm6JeYOb/PGlxnTvh6kizUgtplGA9m55l09zNgMhi8x4deQLCyH7Awg==","mode":420,"size":173448},"ts5.0/jsx-dev-runtime.d.ts":{"checkedAt":1794532108360,"integrity":"sha512-kfwG4lDDX4h5KOV4BHqS4+7ryLLEESLgz1GX2KMAfuFWX1dL0vloYHCRDvi3UO88hLSHUZmMgK6PDRQLBCmulQ==","mode":420,"size":1366},"ts5.0/jsx-runtime.d.ts":{"checkedAt":1794532108360,"integrity":"sha512-4698Qs9UGsgyZGnMPlDWtpTIusO2yBE4Sh/rQmgg4XPHLq8ZTwBgjXa8kH+xoQ8rBC8V4ztwqhkaYN1e0qjwWw==","mode":420,"size":1158}}}

.pnpm-store/v3/files/b4/117afd7b78e27bf1c4927ef42b6d111d68b99f4c32efd74231d53c435cb6d57ce2e1d19650fb048c06afaafec7c98bfc523f06ff7dabf3c399066ca15cf965

@@ -0,0 +1,203 @@
+var balanced = require('balanced-match');
+
+module.exports = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
+
+  var parts = [];
+  var m = balanced('{', '}', str);
+
+  if (!m)
+    return str.split(',');
+
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+
+  parts.push.apply(parts, p);
+
+  return parts;
+}
+
+function expandTop(str) {
+  if (!str)
+    return [];
+
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
+
+  return expand(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+
+function expand(str, isTop) {
+  var expansions = [];
+
+  var m = balanced('{', '}', str);
+  if (!m) return [str];
+
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand(m.post, false)
+    : [''];
+
+  if (/\$$/.test(m.pre)) {    
+    for (var k = 0; k < post.length; k++) {
+      var expansion = pre+ '{' + m.body + '}' + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    var isSequence = isNumericSequence || isAlphaSequence;
+    var isOptions = m.body.indexOf(',') >= 0;
+    if (!isSequence && !isOptions) {
+      // {a},b}
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + '{' + m.body + escClose + m.post;
+        return expand(str);
+      }
+      return [str];
+    }
+
+    var n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1) {
+        // x{{a,b}}y ==> x{a}y x{b}y
+        n = expand(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map(function(p) {
+            return m.pre + n[0] + p;
+          });
+        }
+      }
+    }
+
+    // at this point, n is the parts, and we know it's not a comma set
+    // with a single entry.
+    var N;
+
+    if (isSequence) {
+      var x = numeric(n[0]);
+      var y = numeric(n[1]);
+      var width = Math.max(n[0].length, n[1].length)
+      var incr = n.length == 3
+        ? Math.abs(numeric(n[2]))
+        : 1;
+      var test = lte;
+      var reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      var pad = n.some(isPadded);
+
+      N = [];
+
+      for (var i = x; test(i, y); i += incr) {
+        var c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === '\\')
+            c = '';
+        } else {
+          c = String(i);
+          if (pad) {
+            var need = width - c.length;
+            if (need > 0) {
+              var z = new Array(need + 1).join('0');
+              if (i < 0)
+                c = '-' + z + c.slice(1);
+              else
+                c = z + c;
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+
+      for (var j = 0; j < n.length; j++) {
+        N.push.apply(N, expand(n[j], false));
+      }
+    }
+
+    for (var j = 0; j < N.length; j++) {
+      for (var k = 0; k < post.length; k++) {
+        var expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion)
+          expansions.push(expansion);
+      }
+    }
+  }
+
+  return expansions;
+}
+

.pnpm-store/v3/files/b4/13db338d467ed55379a69237f63c67867a1bfdf9217678d48ee1c56258410564001985f3bc71adadedc68ed8f3bc70e61441ac6b1000d55f25da93223afd07

@@ -0,0 +1,51 @@
+{
+  "name": "react",
+  "description": "React is a JavaScript library for building user interfaces.",
+  "keywords": [
+    "react"
+  ],
+  "version": "19.2.0",
+  "homepage": "https://react.dev/",
+  "bugs": "https://github.com/facebook/react/issues",
+  "license": "MIT",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "index.js",
+    "cjs/",
+    "compiler-runtime.js",
+    "jsx-runtime.js",
+    "jsx-runtime.react-server.js",
+    "jsx-dev-runtime.js",
+    "jsx-dev-runtime.react-server.js",
+    "react.react-server.js"
+  ],
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "react-server": "./react.react-server.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json",
+    "./jsx-runtime": {
+      "react-server": "./jsx-runtime.react-server.js",
+      "default": "./jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "react-server": "./jsx-dev-runtime.react-server.js",
+      "default": "./jsx-dev-runtime.js"
+    },
+    "./compiler-runtime": {
+      "react-server": "./compiler-runtime.js",
+      "default": "./compiler-runtime.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/react.git",
+    "directory": "packages/react"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  }
+}

.pnpm-store/v3/files/b4/145847aad63e7b66081a1e032615b00c7b50d467259b7896783bd47d21c05230dea9644b77dac6ef37517f350dbc897645cfa542c20304e9f91b041f8d678f

@@ -0,0 +1,55 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class UseFilePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string} filename filename
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filename, target) {
+		this.source = source;
+		this.filename = filename;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UseFilePlugin", (request, resolveContext, callback) => {
+				const filePath = resolver.join(
+					/** @type {string} */ (request.path),
+					this.filename,
+				);
+
+				/** @type {ResolveRequest} */
+				const obj = {
+					...request,
+					path: filePath,
+					relativePath:
+						request.relativePath &&
+						resolver.join(request.relativePath, this.filename),
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`using path: ${filePath}`,
+					resolveContext,
+					callback,
+				);
+			});
+	}
+};

.pnpm-store/v3/files/b4/14aa93ea262d73c746985c017591a5d276c6f81dc90caa8c4f0e535666f0655a2b199f6fe25b82ac44dc1fd5b0dfd09b9d1dfe5d34c9068e2e0205c5377558

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const esnext_iterator: LibDefinition;

.pnpm-store/v3/files/b4/16071850ca573fdbcd5708b55eb9db1a3ff3f03f7bb4eca5f4ea1aa9ebbce2144077dc4bec7aa37ac68b1bf1b92114a8d6238f4fad87af808c8ef3774242fc

@@ -0,0 +1,3 @@
+declare const x: typeof Reflect.getPrototypeOf | null;
+
+export = x;

.pnpm-store/v3/files/b4/1620d96dbd80e5acac39e6bcec498d8449e001ca9481c656baad01e2ca16081b2cb8e405098fc9a2587b25829cbd8c8c9656d8a924228ca4053d6dd380b64e

@@ -0,0 +1,232 @@
+import * as tailwind_variants from 'tailwind-variants';
+import { VariantProps } from 'tailwind-variants';
+import * as tailwind_variants_dist_config from 'tailwind-variants/dist/config';
+
+/**
+ * Link wrapper **Tailwind Variants** component
+ *
+ * @example
+ * <a className={link({ color: "secondary", isBlock: true })} href="#" />
+ */
+declare const link: tailwind_variants.TVReturnType<{
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}, undefined, string[], tailwind_variants_dist_config.TVConfig<{
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}, {
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}>, {
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}, undefined, tailwind_variants.TVReturnType<{
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}, undefined, string[], tailwind_variants_dist_config.TVConfig<{
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}, {
+    size: {
+        sm: "text-small";
+        md: "text-medium";
+        lg: "text-large";
+    };
+    color: {
+        foreground: "text-foreground";
+        primary: "text-primary";
+        secondary: "text-secondary";
+        success: "text-success";
+        warning: "text-warning";
+        danger: "text-danger";
+    };
+    underline: {
+        none: "no-underline";
+        hover: "hover:underline";
+        always: "underline";
+        active: "active:underline";
+        focus: "focus:underline";
+    };
+    isBlock: {
+        true: string[];
+        false: "hover:opacity-80 active:opacity-disabled transition-opacity";
+    };
+    isDisabled: {
+        true: "opacity-disabled cursor-default pointer-events-none";
+    };
+    disableAnimation: {
+        true: "after:transition-none transition-none";
+    };
+}>, unknown, unknown, undefined>>;
+declare const linkAnchorClasses = "flex mx-1 text-current self-center";
+type LinkVariantProps = VariantProps<typeof link>;
+
+export { LinkVariantProps, link, linkAnchorClasses };

.pnpm-store/v3/files/b4/1643aac9000e6e5fec79bedad1abdb528418435e31f1a780ffb77cf248d22c849ce6d80603a87520eb2fafb63f46d942c8168d516e24cda3d09362ce667a03

@@ -0,0 +1,43 @@
+{
+  "name": "micromark-util-symbol",
+  "version": "2.0.1",
+  "description": "micromark utility with symbols",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "util",
+    "utility",
+    "symbol"
+  ],
+  "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark-util-symbol",
+  "bugs": "https://github.com/micromark/micromark/issues",
+  "funding": [
+    {
+      "type": "GitHub Sponsors",
+      "url": "https://github.com/sponsors/unifiedjs"
+    },
+    {
+      "type": "OpenCollective",
+      "url": "https://opencollective.com/unified"
+    }
+  ],
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "lib/"
+  ],
+  "exports": "./lib/default.js",
+  "xo": {
+    "envs": [
+      "shared-node-browser"
+    ],
+    "prettier": true,
+    "rules": {
+      "unicorn/prefer-code-point": "off"
+    }
+  }
+}

.pnpm-store/v3/files/b4/1862d8f3250a83be361645fb1e6e049a3e673f0a5850ba07ee6201588b01b98bc5d9c539a1fc234e328e86547ca2a142936cc08545ab97ac0300e80efeb179

@@ -0,0 +1 @@
+export * from './syntax.mjs';

.pnpm-store/v3/files/b4/190726ed99344d1747c099c4f89acfe76910b8dbbe736767a4b269d851ba6ad43aaca0fb54e88d93b18833eab6080d0d678f143f6eaac49c64d94418277a6d

@@ -0,0 +1 @@
+module.exports = require('./lib').getLiteralPropValue; // eslint-disable-line import/no-unresolved

.pnpm-store/v3/files/b4/219fc082745c97fde84870e378065552fd8deb04f992188af096a9b9aef5473b6410d1b447e99a73ff72cf2a425c2a767919d5fa637e6bfe2a870bfc821884

@@ -0,0 +1,19 @@
+// const defaultLogger = debug('SimpleWebAuthn');
+/**
+ * Generate an instance of a `debug` logger that extends off of the "simplewebauthn" namespace for
+ * consistent naming.
+ *
+ * See https://www.npmjs.com/package/debug for information on how to control logging output when
+ * using @simplewebauthn/server
+ *
+ * Example:
+ *
+ * ```
+ * const log = getLogger('mds');
+ * log('hello'); // simplewebauthn:mds hello +0ms
+ * ```
+ */
+export function getLogger(_name) {
+    // This is a noop for now while I search for a better debug logger technique
+    return (_message, ..._rest) => { };
+}

.pnpm-store/v3/files/b4/22a953dbb0d4723eec8856070d4dca33c5e70836865abd4b160f0464d4ecff1263fa13b1f784fd76078fb4633f41e596418b2f5425dcad7abd9f4780deeabb

@@ -0,0 +1 @@
+module.exports={A:{A:{"2":"K D E F A B wC"},B:{"1":"0 1 2 3 4 5 Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I","2":"C L M G N O P"},C:{"1":"0 1 2 3 4 5 6B 7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC LC Q H R WC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I XC MC YC yC zC","2":"6 7 8 9 xC TC J ZB K D E F A B C L M G N O P aB AB BB CB DB EB FB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB 0C 1C","132":"4B VC 5B","450":"wB xB yB zB 0B 1B 2B 3B UC"},D:{"1":"0 1 2 3 4 5 DC EC FC GC HC IC JC KC LC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I XC MC YC","2":"6 7 8 9 J ZB K D E F A B C L M G N O P aB AB BB CB DB EB FB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB","706":"zB 0B 1B 2B 3B UC 4B VC 5B 6B 7B 8B 9B AC BC CC"},E:{"1":"M G 8C 9C bC cC PC AD QC dC eC fC gC hC BD RC iC jC kC lC mC CD SC nC oC pC qC rC sC tC DD ED","2":"J ZB K D E F A B C 2C ZC 3C 4C 5C 6C aC NC","1028":"L OC 7C"},F:{"1":"0 1 2 3 4 5 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC LC Q H R WC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"6 7 8 9 F B C G N O P aB AB BB CB DB EB FB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB FD GD HD ID NC uC JD OC","706":"zB 0B 1B"},G:{"1":"WD XD YD ZD aD bD cD dD bC cC PC eD QC dC eC fC gC hC fD RC iC jC kC lC mC gD SC nC oC pC qC rC sC tC","2":"E ZC KD vC LD MD ND OD PD QD RD SD TD UD VD"},H:{"2":"hD"},I:{"1":"I","2":"TC J iD jD kD lD vC mD nD"},J:{"2":"D A"},K:{"1":"H","2":"A B C NC uC OC"},L:{"1":"I"},M:{"1":"MC"},N:{"2":"A B"},O:{"1":"PC"},P:{"1":"6 7 8 9 AB BB CB DB EB FB aC tD uD vD wD xD QC RC SC yD","2":"J oD pD qD rD sD"},Q:{"1":"zD"},R:{"1":"0D"},S:{"1":"2D","2":"1D"}},B:6,C:"TLS 1.3",D:true};

.pnpm-store/v3/files/b4/25832b999da4df628034ac1fa1add9c907cafd0635389174b3dae1c160f38348bcbe96b08c174ccc19cc188221f652495a6a96548599f24a393b0ad47ba850

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you 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
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export * from './useToolbar';

.pnpm-store/v3/files/b4/2e9b16d76a32d58d302cb93fe7e1d733d91401d215689382694e480b8e6ad419957d82d7094ce038d3a4715b69fecc0d1ccbda008d83b0bbb465f7e855d1c0

@@ -0,0 +1,51 @@
+"use strict"
+
+const {
+    definePrototypeMethodHandler,
+} = require("../util/define-prototype-method-handler")
+
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                "disallow the `ArrayBuffer.prototype.transfer` method.",
+            category: "ES2024",
+            recommended: false,
+            url: "http://eslint-community.github.io/eslint-plugin-es-x/rules/no-arraybuffer-prototype-transfer.html",
+        },
+        fixable: null,
+        messages: {
+            forbidden: "ES2024 '{{name}}' method is forbidden.",
+            forbiddenForDetached:
+                "ES2024 'ArrayBuffer.prototype.detached' property is forbidden.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    aggressive: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "problem",
+    },
+    create(context) {
+        return definePrototypeMethodHandler(
+            context,
+            {
+                ArrayBuffer: ["detached", "transfer", "transferToFixedLength"],
+            },
+            {
+                createReport({ propertyName }) {
+                    return {
+                        messageId:
+                            propertyName === "detached"
+                                ? "forbiddenForDetached"
+                                : "forbidden",
+                    }
+                },
+            },
+        )
+    },
+}

.pnpm-store/v3/files/b4/31c9221edff0e1ef17df299f6204e13b52d95c13f61941fc40811cbdadf90f0c2a7d39a98fa14d60f67991c48cc8652948e2afbe6e0004bfb006b484e762d8

@@ -0,0 +1,3 @@
+# @react-stately/overlays
+
+This package is part of [react-spectrum](https://github.com/adobe/react-spectrum). See the repo for more details.

.pnpm-store/v3/files/b4/35ad11e65962a4f661c372d402c09b370a002f73c9c77d8f2a5f8d91a11dac97eae4982536b1b3ab0b67ce18709792fe62c2e3ccf42fd238a96b56801d9921

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as util from 'util';
+export declare const parseArgs: typeof util.parseArgs;
+//# sourceMappingURL=parse-args.d.ts.map

.pnpm-store/v3/files/b4/382b47d39ceb6e4eedb4285d04509780c57eca2d4e3a2953a6d3e7b78a77e710781b3c1ea4714b9441286894a580f1b247d55388c499ed6a3f3315a65c50d6

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["error.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH,gCAFW,MAAM,QAOhB"}

.pnpm-store/v3/files/b4/38b452afbabde3b2d89ad6c1ff6575a499e07ebe0db80651703800b335323f400a54a098ce24d88f0a3e64cab7b0371dcc20bccdac3a9c84369ab2c2e36f80

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _iterableToArrayLimit;
+function _iterableToArrayLimit(arr, i) {
+  var iterator = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (iterator == null) return;
+  var _arr = [];
+  var iteratorNormalCompletion = true;
+  var didIteratorError = false;
+  var step, iteratorError, next, _return;
+  try {
+    next = (iterator = iterator.call(arr)).next;
+    if (i === 0) {
+      if (Object(iterator) !== iterator) return;
+      iteratorNormalCompletion = false;
+    } else {
+      for (; !(iteratorNormalCompletion = (step = next.call(iterator)).done); iteratorNormalCompletion = true) {
+        _arr.push(step.value);
+        if (_arr.length === i) break;
+      }
+    }
+  } catch (err) {
+    didIteratorError = true;
+    iteratorError = err;
+  } finally {
+    try {
+      if (!iteratorNormalCompletion && iterator["return"] != null) {
+        _return = iterator["return"]();
+        if (Object(_return) !== _return) return;
+      }
+    } finally {
+      if (didIteratorError) throw iteratorError;
+    }
+  }
+  return _arr;
+}
+
+//# sourceMappingURL=iterableToArrayLimit.js.map

.pnpm-store/v3/files/b4/391d9e17167c04d02e4f8e7724a4f7ea897b7cba3d2e72d9bcbddf93de4d9ffc91a50d4e090709128013f35fd3c7d6ffcea19d4c79e25035375b16bbb3422f

@@ -0,0 +1,22 @@
+import { Index } from './indexed.mjs';
+import { MappedResult } from '../mapped/index.mjs';
+import { Clone } from '../clone/value.mjs';
+// prettier-ignore
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: Index(type, [key], Clone(options)) };
+}
+// prettier-ignore
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, left) => {
+        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIndexProperties(type, mappedKey, options) {
+    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+export function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return MappedResult(properties);
+}

.pnpm-store/v3/files/b4/3a90c65b22858b01ae8ecd30607f7e91355d42015504e49e9603fe6eb33a463fa3101e80840bf6402eb67d88d02acdc404b5804b6c63498f1366aabb196920

@@ -0,0 +1,33 @@
+import { OneBotAction } from '../../action/OneBotAction';
+import { Static } from '@sinclair/typebox';
+declare const PayloadSchema: import("@sinclair/typebox").TObject<{
+    flag: import("@sinclair/typebox").TString;
+    approve: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TString]>>;
+    reason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+    count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+type PayloadType = Static<typeof PayloadSchema>;
+declare const ReturnSchema: import("@sinclair/typebox").TNull;
+type ReturnType = Static<typeof ReturnSchema>;
+export default class SetGroupAddRequest extends OneBotAction<PayloadType, ReturnType> {
+    actionName: "set_group_add_request";
+    payloadSchema: import("@sinclair/typebox").TObject<{
+        flag: import("@sinclair/typebox").TString;
+        approve: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TString]>>;
+        reason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    returnSchema: import("@sinclair/typebox").TNull;
+    actionSummary: string;
+    actionDescription: string;
+    actionTags: string[];
+    payloadExample: {
+        flag: string;
+        sub_type: string;
+        approve: boolean;
+    };
+    returnExample: null;
+    _handle(payload: PayloadType): Promise<null>;
+    private findNotify;
+}
+export {};

.pnpm-store/v3/files/b4/3c6540d11c08a63648cf53cd4a7b030a8aad7f0180dd5595de62cc3e59c0f90cf8f3c97e5c411397977e4a26b5f82af23e03796cf76c6867332d7ed3c2a26c

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScope = void 0;
+const ScopeBase_1 = require("./ScopeBase");
+const ScopeType_1 = require("./ScopeType");
+class TypeScope extends ScopeBase_1.ScopeBase {
+    constructor(scopeManager, upperScope, block) {
+        super(scopeManager, ScopeType_1.ScopeType.type, upperScope, block, false);
+    }
+}
+exports.TypeScope = TypeScope;

.pnpm-store/v3/files/b4/3f1826e6ed4cc6f57053b5e0262d45ba1bcb6d7c3b08f74fb9210a2a306aa59571b0e9d425b1e25d96845efc2abf8872d6703371f0445e7d16d3d7babf69f5

@@ -0,0 +1,56 @@
+export declare const UserActionsExamples: {
+    GetCookies: {
+        payload: {
+            domain: string;
+        };
+        response: {
+            cookies: string;
+        };
+    };
+    GetFriendList: {
+        payload: {};
+        response: {
+            user_id: number;
+            nickname: string;
+            remark: string;
+        }[];
+    };
+    GetRecentContact: {
+        payload: {
+            count: number;
+        };
+        response: {
+            lastestMsg: string;
+            peerUin: string;
+            remark: string;
+            msgTime: string;
+            chatType: number;
+            msgId: string;
+            sendNickName: string;
+            sendMemberName: string;
+            peerName: string;
+        }[];
+    };
+    SendLike: {
+        payload: {
+            user_id: string;
+            times: number;
+        };
+        response: {};
+    };
+    SetFriendAddRequest: {
+        payload: {
+            flag: string;
+            approve: boolean;
+            remark: string;
+        };
+        response: {};
+    };
+    SetFriendRemark: {
+        payload: {
+            user_id: string;
+            remark: string;
+        };
+        response: {};
+    };
+};

.pnpm-store/v3/files/b4/400b1aad1e5619b45cd9f09986e916dd52679e1d69132c9e12d25b05652b94783dc9b36b44f0e3eefb452d905b027df95a9949ea76c5ead517698f76207ec1

@@ -0,0 +1,3 @@
+import CryptoJS = require("./index");
+
+export = CryptoJS.lib.WordArray;

.pnpm-store/v3/files/b4/456762206ee6e4185722a9105a1e8efde3232af1129e9c8ef16f56f079d166ae94a7f0e515bdcd16c3897d8733d72eba7d78a060939b722e5acfe3344e310c

@@ -0,0 +1,369 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { READ } = require("eslint-utils")
+const checkUnsupportedBuiltins = require("../../util/check-unsupported-builtins")
+const enumeratePropertyNames = require("../../util/enumerate-property-names")
+
+/*eslint-disable camelcase */
+const trackMap = {
+    globals: {
+        queueMicrotask: {
+            [READ]: { supported: "12.0.0", experimental: "11.0.0" },
+        },
+        require: {
+            resolve: {
+                paths: { [READ]: { supported: "8.9.0" } },
+            },
+        },
+    },
+    modules: {
+        assert: {
+            strict: {
+                [READ]: { supported: "9.9.0", backported: ["8.13.0"] },
+                doesNotReject: { [READ]: { supported: "10.0.0" } },
+                rejects: { [READ]: { supported: "10.0.0" } },
+            },
+            deepStrictEqual: { [READ]: { supported: "4.0.0" } },
+            doesNotReject: { [READ]: { supported: "10.0.0" } },
+            notDeepStrictEqual: { [READ]: { supported: "4.0.0" } },
+            rejects: { [READ]: { supported: "10.0.0" } },
+        },
+        async_hooks: {
+            [READ]: { supported: "8.0.0" },
+            createHook: { [READ]: { supported: "8.1.0" } },
+        },
+        buffer: {
+            Buffer: {
+                alloc: { [READ]: { supported: "4.5.0" } },
+                allocUnsafe: { [READ]: { supported: "4.5.0" } },
+                allocUnsafeSlow: { [READ]: { supported: "4.5.0" } },
+                from: { [READ]: { supported: "4.5.0" } },
+            },
+            kMaxLength: { [READ]: { supported: "3.0.0" } },
+            transcode: { [READ]: { supported: "7.1.0" } },
+            constants: { [READ]: { supported: "8.2.0" } },
+        },
+        child_process: {
+            ChildProcess: { [READ]: { supported: "2.2.0" } },
+        },
+        console: {
+            clear: { [READ]: { supported: "8.3.0", backported: ["6.13.0"] } },
+            count: { [READ]: { supported: "8.3.0", backported: ["6.13.0"] } },
+            countReset: {
+                [READ]: { supported: "8.3.0", backported: ["6.13.0"] },
+            },
+            debug: { [READ]: { supported: "8.0.0" } },
+            dirxml: { [READ]: { supported: "8.0.0" } },
+            group: { [READ]: { supported: "8.5.0" } },
+            groupCollapsed: { [READ]: { supported: "8.5.0" } },
+            groupEnd: { [READ]: { supported: "8.5.0" } },
+            table: { [READ]: { supported: "10.0.0" } },
+            markTimeline: { [READ]: { supported: "8.0.0" } },
+            profile: { [READ]: { supported: "8.0.0" } },
+            profileEnd: { [READ]: { supported: "8.0.0" } },
+            timeLog: { [READ]: { supported: "10.7.0" } },
+            timeStamp: { [READ]: { supported: "8.0.0" } },
+            timeline: { [READ]: { supported: "8.0.0" } },
+            timelineEnd: { [READ]: { supported: "8.0.0" } },
+        },
+        crypto: {
+            Certificate: {
+                exportChallenge: { [READ]: { supported: "9.0.0" } },
+                exportPublicKey: { [READ]: { supported: "9.0.0" } },
+                verifySpkac: { [READ]: { supported: "9.0.0" } },
+            },
+            ECDH: { [READ]: { supported: "8.8.0", backported: ["6.13.0"] } },
+            KeyObject: { [READ]: { supported: "11.6.0" } },
+            createPrivateKey: { [READ]: { supported: "11.6.0" } },
+            createPublicKey: { [READ]: { supported: "11.6.0" } },
+            createSecretKey: { [READ]: { supported: "11.6.0" } },
+            constants: { [READ]: { supported: "6.3.0" } },
+            fips: { [READ]: { supported: "6.0.0" } },
+            generateKeyPair: { [READ]: { supported: "10.12.0" } },
+            generateKeyPairSync: { [READ]: { supported: "10.12.0" } },
+            getCurves: { [READ]: { supported: "2.3.0" } },
+            getFips: { [READ]: { supported: "10.0.0" } },
+            privateEncrypt: { [READ]: { supported: "1.1.0" } },
+            publicDecrypt: { [READ]: { supported: "1.1.0" } },
+            randomFillSync: {
+                [READ]: { supported: "7.10.0", backported: ["6.13.0"] },
+            },
+            randomFill: {
+                [READ]: { supported: "7.10.0", backported: ["6.13.0"] },
+            },
+            scrypt: { [READ]: { supported: "10.5.0" } },
+            scryptSync: { [READ]: { supported: "10.5.0" } },
+            setFips: { [READ]: { supported: "10.0.0" } },
+            sign: { [READ]: { supported: "12.0.0" } },
+            timingSafeEqual: { [READ]: { supported: "6.6.0" } },
+            verify: { [READ]: { supported: "12.0.0" } },
+        },
+        dns: {
+            Resolver: { [READ]: { supported: "8.3.0" } },
+            resolvePtr: { [READ]: { supported: "6.0.0" } },
+            promises: {
+                [READ]: {
+                    supported: "11.14.0",
+                    backported: ["10.17.0"],
+                    experimental: "10.6.0",
+                },
+            },
+        },
+        events: {
+            EventEmitter: {
+                once: {
+                    [READ]: { supported: "11.13.0", backported: ["10.16.0"] },
+                },
+            },
+            once: { [READ]: { supported: "11.13.0", backported: ["10.16.0"] } },
+        },
+        fs: {
+            Dirent: { [READ]: { supported: "10.10.0" } },
+            copyFile: { [READ]: { supported: "8.5.0" } },
+            copyFileSync: { [READ]: { supported: "8.5.0" } },
+            mkdtemp: { [READ]: { supported: "5.10.0" } },
+            mkdtempSync: { [READ]: { supported: "5.10.0" } },
+            realpath: {
+                native: { [READ]: { supported: "9.2.0" } },
+            },
+            realpathSync: {
+                native: { [READ]: { supported: "9.2.0" } },
+            },
+            promises: {
+                [READ]: {
+                    supported: "11.14.0",
+                    backported: ["10.17.0"],
+                    experimental: "10.1.0",
+                },
+            },
+            writev: { [READ]: { supported: "12.9.0" } },
+            writevSync: { [READ]: { supported: "12.9.0" } },
+        },
+        http2: {
+            [READ]: {
+                supported: "10.10.0",
+                backported: ["8.13.0"],
+                experimental: "8.4.0",
+            },
+        },
+        inspector: {
+            [READ]: { supported: null, experimental: "8.0.0" },
+        },
+        module: {
+            Module: {
+                builtinModules: {
+                    [READ]: {
+                        supported: "9.3.0",
+                        backported: ["6.13.0", "8.10.0"],
+                    },
+                },
+                createRequireFromPath: { [READ]: { supported: "10.12.0" } },
+                createRequire: { [READ]: { supported: "12.2.0" } },
+                syncBuiltinESMExports: { [READ]: { supported: "12.12.0" } },
+            },
+            builtinModules: {
+                [READ]: {
+                    supported: "9.3.0",
+                    backported: ["6.13.0", "8.10.0"],
+                },
+            },
+            createRequireFromPath: { [READ]: { supported: "10.12.0" } },
+            createRequire: { [READ]: { supported: "12.2.0" } },
+            syncBuiltinESMExports: { [READ]: { supported: "12.12.0" } },
+        },
+        os: {
+            constants: {
+                [READ]: { supported: "6.3.0" },
+                priority: { [READ]: { supported: "10.10.0" } },
+            },
+            getPriority: { [READ]: { supported: "10.10.0" } },
+            homedir: { [READ]: { supported: "2.3.0" } },
+            setPriority: { [READ]: { supported: "10.10.0" } },
+            userInfo: { [READ]: { supported: "6.0.0" } },
+        },
+        path: {
+            toNamespacedPath: { [READ]: { supported: "9.0.0" } },
+        },
+        perf_hooks: {
+            [READ]: { supported: "8.5.0" },
+            monitorEventLoopDelay: { [READ]: { supported: "11.10.0" } },
+        },
+        process: {
+            allowedNodeEnvironmentFlags: { [READ]: { supported: "10.10.0" } },
+            argv0: { [READ]: { supported: "6.4.0" } },
+            channel: { [READ]: { supported: "7.1.0" } },
+            cpuUsage: { [READ]: { supported: "6.1.0" } },
+            emitWarning: { [READ]: { supported: "6.0.0" } },
+            getegid: { [READ]: { supported: "2.0.0" } },
+            geteuid: { [READ]: { supported: "2.0.0" } },
+            hasUncaughtExceptionCaptureCallback: {
+                [READ]: { supported: "9.3.0" },
+            },
+            hrtime: {
+                bigint: { [READ]: { supported: "10.7.0" } },
+            },
+            ppid: {
+                [READ]: {
+                    supported: "9.2.0",
+                    backported: ["6.13.0", "8.10.0"],
+                },
+            },
+            release: { [READ]: { supported: "3.0.0" } },
+            report: { [READ]: { supported: null, experimental: "11.8.0" } },
+            resourceUsage: { [READ]: { supported: "12.6.0" } },
+            setegid: { [READ]: { supported: "2.0.0" } },
+            seteuid: { [READ]: { supported: "2.0.0" } },
+            setUncaughtExceptionCaptureCallback: {
+                [READ]: { supported: "9.3.0" },
+            },
+            stdout: {
+                getColorDepth: { [READ]: { supported: "9.9.0" } },
+                hasColor: { [READ]: { supported: "11.13.0" } },
+            },
+            stderr: {
+                getColorDepth: { [READ]: { supported: "9.9.0" } },
+                hasColor: { [READ]: { supported: "11.13.0" } },
+            },
+        },
+        stream: {
+            Readable: {
+                from: {
+                    [READ]: { supported: "12.3.0", backported: ["10.17.0"] },
+                },
+            },
+            finished: { [READ]: { supported: "10.0.0" } },
+            pipeline: { [READ]: { supported: "10.0.0" } },
+        },
+        trace_events: {
+            [READ]: { supported: "10.0.0" },
+        },
+        url: {
+            URL: { [READ]: { supported: "7.0.0", backported: ["6.13.0"] } },
+            URLSearchParams: {
+                [READ]: { supported: "7.5.0", backported: ["6.13.0"] },
+            },
+            domainToASCII: { [READ]: { supported: "7.4.0" } },
+            domainToUnicode: { [READ]: { supported: "7.4.0" } },
+        },
+        util: {
+            callbackify: { [READ]: { supported: "8.2.0" } },
+            formatWithOptions: { [READ]: { supported: "10.0.0" } },
+            getSystemErrorName: {
+                [READ]: { supported: "9.7.0", backported: ["8.12.0"] },
+            },
+            inspect: {
+                custom: { [READ]: { supported: "6.6.0" } },
+                defaultOptions: { [READ]: { supported: "6.4.0" } },
+                replDefaults: { [READ]: { supported: "11.12.0" } },
+            },
+            isDeepStrictEqual: { [READ]: { supported: "9.0.0" } },
+            promisify: { [READ]: { supported: "8.0.0" } },
+            TextDecoder: {
+                [READ]: { supported: "8.9.0", experimental: "8.3.0" },
+            },
+            TextEncoder: {
+                [READ]: { supported: "8.9.0", experimental: "8.3.0" },
+            },
+            types: {
+                [READ]: { supported: "10.0.0" },
+                isBoxedPrimitive: { [READ]: { supported: "10.11.0" } },
+            },
+        },
+        v8: {
+            [READ]: { supported: "1.0.0" },
+            DefaultDeserializer: { [READ]: { supported: "8.0.0" } },
+            DefaultSerializer: { [READ]: { supported: "8.0.0" } },
+            Deserializer: { [READ]: { supported: "8.0.0" } },
+            Serializer: { [READ]: { supported: "8.0.0" } },
+            cachedDataVersionTag: { [READ]: { supported: "8.0.0" } },
+            deserialize: { [READ]: { supported: "8.0.0" } },
+            getHeapCodeStatistics: { [READ]: { supported: "12.8.0" } },
+            getHeapSnapshot: { [READ]: { supported: "11.13.0" } },
+            getHeapSpaceStatistics: { [READ]: { supported: "6.0.0" } },
+            serialize: { [READ]: { supported: "8.0.0" } },
+            writeHeapSnapshot: { [READ]: { supported: "11.13.0" } },
+        },
+        vm: {
+            Module: { [READ]: { supported: "9.6.0" } },
+            compileFunction: { [READ]: { supported: "10.10.0" } },
+        },
+        worker_threads: {
+            [READ]: { supported: "12.11.0", experimental: "10.5.0" },
+        },
+    },
+}
+Object.assign(trackMap.globals, {
+    Buffer: trackMap.modules.buffer.Buffer,
+    TextDecoder: {
+        ...trackMap.modules.util.TextDecoder,
+        [READ]: { supported: "11.0.0" },
+    },
+    TextEncoder: {
+        ...trackMap.modules.util.TextEncoder,
+        [READ]: { supported: "11.0.0" },
+    },
+    URL: {
+        ...trackMap.modules.url.URL,
+        [READ]: { supported: "10.0.0" },
+    },
+    URLSearchParams: {
+        ...trackMap.modules.url.URLSearchParams,
+        [READ]: { supported: "10.0.0" },
+    },
+    console: trackMap.modules.console,
+    process: trackMap.modules.process,
+})
+/*eslint-enable camelcase */
+
+module.exports = {
+    meta: {
+        docs: {
+            description:
+                "disallow unsupported Node.js built-in APIs on the specified version",
+            category: "Possible Errors",
+            recommended: true,
+            url:
+                "https://github.com/mysticatea/eslint-plugin-node/blob/v11.1.0/docs/rules/no-unsupported-features/node-builtins.md",
+        },
+        type: "problem",
+        fixable: null,
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    version: {
+                        type: "string",
+                    },
+                    ignores: {
+                        type: "array",
+                        items: {
+                            enum: Array.from(
+                                new Set([
+                                    ...enumeratePropertyNames(trackMap.globals),
+                                    ...enumeratePropertyNames(trackMap.modules),
+                                ])
+                            ),
+                        },
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unsupported:
+                "The '{{name}}' is not supported until Node.js {{supported}}. The configured version range is '{{version}}'.",
+        },
+    },
+    create(context) {
+        return {
+            "Program:exit"() {
+                checkUnsupportedBuiltins(context, trackMap)
+            },
+        }
+    },
+}

.pnpm-store/v3/files/b4/465c5e7754b76c2e56c68be7d2e3081af5dc76c7d0755945e42d8270ab7524593c477608d0affc35a751b7dcf9706f1c59ec7f508f91c34e848969558aab09

@@ -0,0 +1,7 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { IconSvgProps } from '../types.js';
+import 'react';
+
+declare const AddNoteBulkIcon: (props: IconSvgProps) => react_jsx_runtime.JSX.Element;
+
+export { AddNoteBulkIcon };

.pnpm-store/v3/files/b4/48780275ceb8eb11558ab5b15532c583778983dd7ecc25b316da08bda7f1130012efee03796d1f17f9afa29ac5e5933aa2d17c6c291bd3d366d6f2d8914b3e

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge.js","sourceRoot":"","sources":["../../src/utils/deep-merge.ts"],"names":[],"mappings":"AAOA,MAAM,UAAU,gBAAgB,CAAC,GAAY;IAC3C,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AACtE,CAAC;AAUD,MAAM,UAAU,SAAS,CACvB,QAAoB,EAAE,EACtB,SAAqB,EAAE;IAGvB,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IAErE,OAAO,MAAM,CAAC,WAAW,CACvB,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QAClB,MAAM,WAAW,GAAG,GAAG,IAAI,KAAK,CAAA;QAChC,MAAM,YAAY,GAAG,GAAG,IAAI,MAAM,CAAA;QAClC,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;QAC7B,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;QAE/B,IAAI,KAAK,CAAA;QACT,IAAI,WAAW,IAAI,YAAY,EAAE,CAAC;YAChC,KAAK;gBAEH,gBAAgB,CAAC,UAAU,CAAC,IAAI,gBAAgB,CAAC,WAAW,CAAC;oBAC3D,CAAC,CAAC,SAAS,CAAC,UAAU,EAAE,WAAW,CAAC;oBACpC,CAAC;wBACC,WAAW,CAAA;QACnB,CAAC;aAAM,IAAI,WAAW,EAAE,CAAC;YACvB,KAAK,GAAG,UAAU,CAAA;QACpB,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,WAAW,CAAA;QACrB,CAAC;QACD,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IACrB,CAAC,CAAC,CACH,CAAA;AACH,CAAC"}

.pnpm-store/v3/files/b4/4e658ff2adcbbf956c7635416698002b6b8ba3c998b57987731413c520a4241b09fefa67de504f757fa2235351cd49d83b5d1057d87f36ad34cc3fb34829f0

@@ -0,0 +1,12 @@
+import {
+  tv
+} from "./chunk-UWE6H66T.mjs";
+
+// src/components/drip.ts
+var drip = tv({
+  base: ["absolute", "will-change-transform", "bg-current", "rounded-full", "animate-drip-expand"]
+});
+
+export {
+  drip
+};

.pnpm-store/v3/files/b4/4f3cd6cad2e4d3a476ba898bf7d87525d42f013449a935a3de92bef973b925805a3faa9c8c3832cd8bcf121aa9ecb5efc552e165a5ff3c09d14fd5150c893a

@@ -0,0 +1,4 @@
+'use strict';
+
+/** @type {import('.')} */
+module.exports = Error;

.pnpm-store/v3/files/b4/4fce85c623f95b92987d51ca94476dca1a6c23df5470fa3497ff03a6f9b4a7e1f033954d5f9e1420ef0b581e8fd030d22622a57114910ac4eb1c77a38fd94d

@@ -0,0 +1,36 @@
+declare namespace stripJsonComments {
+	interface Options {
+		/**
+		Replace comments with whitespace instead of stripping them entirely.
+
+		@default true
+		*/
+		readonly whitespace?: boolean;
+	}
+}
+
+/**
+Strip comments from JSON. Lets you use comments in your JSON files!
+
+It will replace single-line comments `//` and multi-line comments `/**\/` with whitespace. This allows JSON error positions to remain as close as possible to the original source.
+
+@param jsonString - Accepts a string with JSON.
+@returns A JSON string without comments.
+
+@example
+```
+const json = `{
+	// Rainbows
+	"unicorn": "cake"
+}`;
+
+JSON.parse(stripJsonComments(json));
+//=> {unicorn: 'cake'}
+```
+*/
+declare function stripJsonComments(
+	jsonString: string,
+	options?: stripJsonComments.Options
+): string;
+
+export = stripJsonComments;

.pnpm-store/v3/files/b4/4fde2f577255da855a5b6a2ca3c76989bd98f73f5d83f72990f938397c95a974aff03ed6eca2a2f96c7a9007aab4075baabf2866a0fb2ae31b9ea141f9534d

@@ -0,0 +1,4 @@
+type Resolve = (source: string | null) => string;
+export =       function resolver(mapUrl: string | null | undefined, sourceRoot: string | undefined): Resolve;
+export {};
+//# sourceMappingURL=resolve.d.ts.map

.pnpm-store/v3/files/b4/522fd7d4646b2ad2dab71d3e660d4dd2191dcce72fc27124293090fd0cc635ea7be4ca477a5c773f8edc87e6c4a94e1d364a315abd22080f08a4ec46875840

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSystemPolicy = void 0;
+const index_1 = require("../value/guard/index");
+var TypeSystemPolicy;
+(function (TypeSystemPolicy) {
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Instancing
+    // ------------------------------------------------------------------
+    /**
+     * Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+     * references for embedded types, which may cause side effects if type properties are explicitly updated
+     * outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+     * preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+     * it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+     * fastest way to instantiate types. The default setting is `default`.
+     */
+    TypeSystemPolicy.InstanceMode = 'default';
+    // ------------------------------------------------------------------
+    // TypeSystemPolicy: Checking
+    // ------------------------------------------------------------------
+    /** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+    TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    /** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+    TypeSystemPolicy.AllowArrayObject = false;
+    /** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+    TypeSystemPolicy.AllowNaN = false;
+    /** Sets whether `null` should validate for void types. The default is `false` */
+    TypeSystemPolicy.AllowNullVoid = false;
+    /** Checks this value using the ExactOptionalPropertyTypes policy */
+    function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    /** Checks this value using the AllowArrayObjects policy */
+    function IsObjectLike(value) {
+        const isObject = (0, index_1.IsObject)(value);
+        return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !(0, index_1.IsArray)(value);
+    }
+    TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    /** Checks this value as a record using the AllowArrayObjects policy */
+    function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+    }
+    TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    /** Checks this value using the AllowNaN policy */
+    function IsNumberLike(value) {
+        return TypeSystemPolicy.AllowNaN ? (0, index_1.IsNumber)(value) : Number.isFinite(value);
+    }
+    TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    /** Checks this value using the AllowVoidNull policy */
+    function IsVoidLike(value) {
+        const isUndefined = (0, index_1.IsUndefined)(value);
+        return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+    }
+    TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (exports.TypeSystemPolicy = TypeSystemPolicy = {}));

.pnpm-store/v3/files/b4/52b893e094aad56f340c6d65914aca45665938bc3f933e342f6b022951fbd8808d6c089e11d1d2a3600182d2e9df8f8531d996926d0babbcd273dc6cc01cf7

@@ -0,0 +1,295 @@
+/**
+ * @fileoverview Rule to flag use of eval() statement
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const candidatesOfGlobalObject = Object.freeze([
+	"global",
+	"window",
+	"globalThis",
+]);
+
+/**
+ * Checks a given node is a MemberExpression node which has the specified name's
+ * property.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name A name to check.
+ * @returns {boolean} `true` if the node is a MemberExpression node which has
+ *      the specified name's property
+ */
+function isMember(node, name) {
+	return astUtils.isSpecificMemberAccess(node, null, name);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowIndirect: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow the use of `eval()`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-eval",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowIndirect: { type: "boolean" },
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpected: "eval can be harmful.",
+		},
+	},
+
+	create(context) {
+		const [{ allowIndirect }] = context.options;
+		const sourceCode = context.sourceCode;
+		let funcInfo = null;
+
+		/**
+		 * Pushes a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
+		 * Top-level scopes are handled separately.
+		 *
+		 * This is used in order to check whether or not `this` binding is a
+		 * reference to the global object.
+		 * @param {ASTNode} node A node of the scope.
+		 *      For functions, this is one of FunctionDeclaration, FunctionExpression.
+		 *      For class static blocks, this is StaticBlock.
+		 *      For class field initializers, this can be any node that is PropertyDefinition#value.
+		 * @returns {void}
+		 */
+		function enterThisScope(node) {
+			const strict = sourceCode.getScope(node).isStrict;
+
+			funcInfo = {
+				upper: funcInfo,
+				node,
+				strict,
+				isTopLevelOfScript: false,
+				defaultThis: false,
+				initialized: strict,
+			};
+		}
+
+		/**
+		 * Pops a variable scope from the stack.
+		 * @returns {void}
+		 */
+		function exitThisScope() {
+			funcInfo = funcInfo.upper;
+		}
+
+		/**
+		 * Reports a given node.
+		 *
+		 * `node` is `Identifier` or `MemberExpression`.
+		 * The parent of `node` might be `CallExpression`.
+		 *
+		 * The location of the report is always `eval` `Identifier` (or possibly
+		 * `Literal`). The type of the report is `CallExpression` if the parent is
+		 * `CallExpression`. Otherwise, it's the given node type.
+		 * @param {ASTNode} node A node to report.
+		 * @returns {void}
+		 */
+		function report(node) {
+			const parent = node.parent;
+			const locationNode =
+				node.type === "MemberExpression" ? node.property : node;
+
+			const reportNode =
+				parent.type === "CallExpression" && parent.callee === node
+					? parent
+					: node;
+
+			context.report({
+				node: reportNode,
+				loc: locationNode.loc,
+				messageId: "unexpected",
+			});
+		}
+
+		/**
+		 * Reports accesses of `eval` via the global object.
+		 * @param {eslint-scope.Scope} globalScope The global scope.
+		 * @returns {void}
+		 */
+		function reportAccessingEvalViaGlobalObject(globalScope) {
+			for (let i = 0; i < candidatesOfGlobalObject.length; ++i) {
+				const name = candidatesOfGlobalObject[i];
+				const variable = astUtils.getVariableByName(globalScope, name);
+
+				if (!variable) {
+					continue;
+				}
+
+				const references = variable.references;
+
+				for (let j = 0; j < references.length; ++j) {
+					const identifier = references[j].identifier;
+					let node = identifier.parent;
+
+					// To detect code like `window.window.eval`.
+					while (isMember(node, name)) {
+						node = node.parent;
+					}
+
+					// Reports.
+					if (isMember(node, "eval")) {
+						report(node);
+					}
+				}
+			}
+		}
+
+		/**
+		 * Reports all accesses of `eval` (excludes direct calls to eval).
+		 * @param {eslint-scope.Scope} globalScope The global scope.
+		 * @returns {void}
+		 */
+		function reportAccessingEval(globalScope) {
+			const variable = astUtils.getVariableByName(globalScope, "eval");
+
+			if (!variable) {
+				return;
+			}
+
+			const references = variable.references;
+
+			for (let i = 0; i < references.length; ++i) {
+				const reference = references[i];
+				const id = reference.identifier;
+
+				if (id.name === "eval" && !astUtils.isCallee(id)) {
+					// Is accessing to eval (excludes direct calls to eval)
+					report(id);
+				}
+			}
+		}
+
+		if (allowIndirect) {
+			// Checks only direct calls to eval. It's simple!
+			return {
+				"CallExpression:exit"(node) {
+					const callee = node.callee;
+
+					/*
+					 * Optional call (`eval?.("code")`) is not direct eval.
+					 * The direct eval is only step 6.a.vi of https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation
+					 * But the optional call is https://tc39.es/ecma262/#sec-optional-chaining-chain-evaluation
+					 */
+					if (
+						!node.optional &&
+						astUtils.isSpecificId(callee, "eval")
+					) {
+						report(callee);
+					}
+				},
+			};
+		}
+
+		return {
+			"CallExpression:exit"(node) {
+				const callee = node.callee;
+
+				if (astUtils.isSpecificId(callee, "eval")) {
+					report(callee);
+				}
+			},
+
+			Program(node) {
+				const scope = sourceCode.getScope(node),
+					features =
+						context.languageOptions.parserOptions.ecmaFeatures ||
+						{},
+					strict =
+						scope.isStrict ||
+						node.sourceType === "module" ||
+						(features.globalReturn &&
+							scope.childScopes[0].isStrict),
+					isTopLevelOfScript =
+						node.sourceType !== "module" && !features.globalReturn;
+
+				funcInfo = {
+					upper: null,
+					node,
+					strict,
+					isTopLevelOfScript,
+					defaultThis: true,
+					initialized: true,
+				};
+			},
+
+			"Program:exit"(node) {
+				const globalScope = sourceCode.getScope(node);
+
+				exitThisScope();
+				reportAccessingEval(globalScope);
+				reportAccessingEvalViaGlobalObject(globalScope);
+			},
+
+			FunctionDeclaration: enterThisScope,
+			"FunctionDeclaration:exit": exitThisScope,
+			FunctionExpression: enterThisScope,
+			"FunctionExpression:exit": exitThisScope,
+			"PropertyDefinition > *.value": enterThisScope,
+			"PropertyDefinition > *.value:exit": exitThisScope,
+			StaticBlock: enterThisScope,
+			"StaticBlock:exit": exitThisScope,
+
+			ThisExpression(node) {
+				if (!isMember(node.parent, "eval")) {
+					return;
+				}
+
+				/*
+				 * `this.eval` is found.
+				 * Checks whether or not the value of `this` is the global object.
+				 */
+				if (!funcInfo.initialized) {
+					funcInfo.initialized = true;
+					funcInfo.defaultThis = astUtils.isDefaultThisBinding(
+						funcInfo.node,
+						sourceCode,
+					);
+				}
+
+				// `this` at the top level of scripts always refers to the global object
+				if (
+					funcInfo.isTopLevelOfScript ||
+					(!funcInfo.strict && funcInfo.defaultThis)
+				) {
+					// `this.eval` is possible built-in `eval`.
+					report(node.parent);
+				}
+			},
+		};
+	},
+};

.pnpm-store/v3/files/b4/5361406fa69df1c76d7ad58c6fdfaf7866cf00eaeffe6c9773d873f79b1c6d5bdb73d1abcffa6ee09fb5941b307b0aa4a2d5cc66492fb937b053ce6997c4e8

@@ -0,0 +1,38 @@
+// English (Canada) [en-ca]
+import dayjs from '../index';
+var locale = {
+  name: 'en-ca',
+  weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+  months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+  weekdaysShort: 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
+  monthsShort: 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
+  weekdaysMin: 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
+  ordinal: function ordinal(n) {
+    return n;
+  },
+  formats: {
+    LT: 'h:mm A',
+    LTS: 'h:mm:ss A',
+    L: 'YYYY-MM-DD',
+    LL: 'MMMM D, YYYY',
+    LLL: 'MMMM D, YYYY h:mm A',
+    LLLL: 'dddd, MMMM D, YYYY h:mm A'
+  },
+  relativeTime: {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years'
+  }
+};
+dayjs.locale(locale, null, true);
+export default locale;

.pnpm-store/v3/files/b4/537daad533f8079a366681d860a935ba6f98526ce83cc8c578dc945581d7bc78c26740c816f7806f72f9024ae249c195700140447a1084777f852c2d8de0c5

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blaine Bublitz <blaine.bublitz@gmail.com>, Eric Schoffstall <yo@contra.io> and other contributors
+
+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/v3/files/b4/55ac52e1787ec3eb0ed4eb1d8010811f77f2ec013bfa16084b729f492547fd4cf202015053223ce3ebf579006ee9931220ac5ca8e9b1538cca045941186b72

@@ -0,0 +1,14 @@
+import { id_pe, id_ce, id_pkix } from "@peculiar/asn1-x509";
+export const id_pe_ac_auditIdentity = `${id_pe}.4`;
+export const id_pe_aaControls = `${id_pe}.6`;
+export const id_pe_ac_proxying = `${id_pe}.10`;
+export const id_ce_targetInformation = `${id_ce}.55`;
+export const id_aca = `${id_pkix}.10`;
+export const id_aca_authenticationInfo = `${id_aca}.1`;
+export const id_aca_accessIdentity = `${id_aca}.2`;
+export const id_aca_chargingIdentity = `${id_aca}.3`;
+export const id_aca_group = `${id_aca}.4`;
+export const id_aca_encAttrs = `${id_aca}.6`;
+export const id_at = "2.5.4";
+export const id_at_role = `${id_at}.72`;
+export const id_at_clearance = "2.5.1.5.55";

.pnpm-store/v3/files/b4/57ab7e9da8e8d61443712f7b1ea3caa89f75337a7ea78d173b302229ebfa8c188a3f37092614db097954362433dbfae04ac212a7170da566a7bd744665a475

@@ -0,0 +1 @@
+{"mappings":"AAAA,iBAAiB;IAAG,eAAe,CAAC,+DAAS,CAAC;AAC9C","sources":["packages/@react-aria/breadcrumbs/intl/ru-RU.json"],"sourcesContent":["{\n  \"breadcrumbs\": \"Навигация\"\n}\n"],"names":[],"version":3,"file":"ru-RU.main.js.map"}

.pnpm-store/v3/files/b4/5814e01a4564c8389837c9474c59a75234675cb3f0d9f5fcdfa2f0c4c2c321238976f044ebaf786085346011b9fc39d23d3d0bd032050583511df6107072c2

@@ -0,0 +1,820 @@
+export default `flf2a$ 8 6 20 -1 2
+Tanja was written for -=Tanja Lynnx Jackson=- by
+Christopher J. Pirillo "The Locker Gnome" <pirill44@iscssun.uni.edu>
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@
+$$$@@
+ !)  @
+!)11 @
+!)11 @
+ !)  @
+     @
+ !)  @
+     @
+     @@
+*** *** @
+##  ##  @
+##  ##  @
+        @
+        @
+        @
+        @
+        @@
+  #) 33   @
+#)3333333 @
+  #) 33   @
+  #) 33   @
+#)3333333 @
+  #) 33   @
+          @
+          @@
+   S)    @
+ S)4444  @
+S) 44    @
+ S)4444  @
+   S) 44 @
+S)44444  @
+   S)    @
+         @@
+ %)   555 @
+%)   555  @
+    %)5   @
+  %)5     @
+ %)5   55 @
+%)5   55  @
+          @
+          @@
+ &)77    @
+&)  77   @
+ &)77    @
+&)  77   @
+&)   77  @
+ &)77777 @
+         @
+         @@
+*** @
+ ## @
+##  @
+    @
+    @
+    @
+    @
+    @@
+   () @
+ ()   @
+()    @
+()    @
+ ()   @
+   () @
+      @
+      @@
+))    @
+  ))  @
+   )) @
+   )) @
+  ))  @
+))    @
+      @
+      @@
+    *)    @
+*)  8  88 @
+  *)8 8   @
+*)8888888 @
+  *)8 8   @
+*)  8  88 @
+   *)     @
+          @@
+       @
+       @
+  ##   @
+###### @
+  ##   @
+       @
+       @
+       @@
+    @
+    @
+    @
+    @
+*** @
+ ## @
+##  @
+    @@
+        @
+        @
+        @
+####### @
+        @
+        @
+        @
+        @@
+   @
+   @
+   @
+   @
+** @
+## @
+   @
+   @@
+     /)? @
+    /)?  @
+   /)?   @
+  /)?    @
+ /)?     @
+/)?      @
+         @
+         @@
+ 0))))  @
+0)  ))) @
+0) ) )) @
+0) ) )) @
+0))  )) @
+ 0))))  @
+        @
+        @@
+  1)!   @
+ 1)!!   @
+   1)   @
+   1)   @
+   1)   @
+1)!!!!! @
+        @
+        @@
+ 2)AAA  @
+2)   AA @
+    2)  @
+   2)   @
+  2)    @
+2)AAAAA @
+        @
+        @@
+ 3)###  @
+3)   ## @
+   3)#  @
+     3) @
+3)   ## @
+ 3)###  @
+        @
+        @@
+4)   SS @
+4)   SS @
+4)SSSSS @
+     4) @
+     4) @
+     4) @
+        @
+        @@
+5)%%%%  @
+5)      @
+5)%%%%  @
+     5) @
+     5) @
+5)%%%%  @
+        @
+        @@
+ 6)NNN  @
+6)      @
+6)NNNN  @
+6)   NN @
+6)   NN @
+ 6)NNN  @
+        @
+        @@
+7)&&&&& @
+    7)  @
+   7)   @
+  7)    @
+ 7)     @
+7)      @
+        @
+        @@
+ 8)***  @
+8)   ** @
+ 8)***  @
+8)   ** @
+8)   ** @
+ 8)***  @
+        @
+        @@
+ 9)(((  @
+9)   (( @
+ 9)(((( @
+     9) @
+9)   (( @
+ 9)(((  @
+        @
+        @@
+   @
+   @
+## @
+   @
+## @
+   @
+   @
+   @@
+    @
+    @
+ ## @
+    @
+*** @
+ ## @
+##  @
+    @@
+   <) @
+  <)  @
+ <)   @
+<)    @
+ <)   @
+  <)  @
+   <) @
+      @@
+        @
+        @
+####### @
+        @
+####### @
+        @
+        @
+        @@
+>)    @
+ >)   @
+  >)  @
+   >) @
+  >)  @
+ >)   @
+>)    @
+      @@
+ ?)////  @
+?)    // @
+    ?)   @
+   ?)    @
+         @
+   ?)    @
+         @
+         @@
+ A)222  @
+A)    2 @
+A) 2222 @
+A) 2  2 @
+A)  222 @
+ A)     @
+        @
+        @@
+  A)aa   @
+ A)  aa  @
+A)    aa @
+A)aaaaaa @
+A)    aa @
+A)    aa @
+         @
+         @@
+B)bbbb   @
+B)   bb  @
+B)bbbb   @
+B)   bb  @
+B)    bb @
+B)bbbbb  @
+         @
+         @@
+  C)ccc  @
+ C)   cc @
+C)       @
+C)       @
+ C)   cc @
+  C)ccc  @
+         @
+         @@
+D)dddd   @
+D)   dd  @
+D)    dd @
+D)    dd @
+D)    dd @
+D)ddddd  @
+         @
+         @@
+E)eeeeee @
+E)       @
+E)eeeee  @
+E)       @
+E)       @
+E)eeeeee @
+         @
+         @@
+F)ffffff @
+F)       @
+F)fffff  @
+F)       @
+F)       @
+F)       @
+         @
+         @@
+  G)gggg @
+ G)      @
+G)  ggg  @
+G)    gg @
+ G)   gg @
+  G)ggg  @
+         @
+         @@
+H)    hh @
+H)    hh @
+H)hhhhhh @
+H)    hh @
+H)    hh @
+H)    hh @
+         @
+         @@
+I)iiii @
+  I)   @
+  I)   @
+  I)   @
+  I)   @
+I)iiii @
+       @
+       @@
+J)jjjjjj @
+    J)   @
+    J)   @
+J)  jj   @
+J)  jj   @
+ J)jj    @
+         @
+         @@
+K)   kk  @
+K)  kk   @
+K)kkk    @
+K)  kk   @
+K)   kk  @
+K)    kk @
+         @
+         @@
+L)       @
+L)       @
+L)       @
+L)       @
+L)       @
+L)llllll @
+         @
+         @@
+ M)mm mmm  @
+M)  mm  mm @
+M)  mm  mm @
+M)  mm  mm @
+M)      mm @
+M)      mm @
+           @
+           @@
+N)n   nn @
+N)nn  nn @
+N) nn nn @
+N)  nnnn @
+N)   nnn @
+N)    nn @
+         @
+         @@
+ O)oooo  @
+O)    oo @
+O)    oo @
+O)    oo @
+O)    oo @
+ O)oooo  @
+         @
+         @@
+P)ppppp  @
+P)    pp @
+P)ppppp  @
+P)       @
+P)       @
+P)       @
+         @
+         @@
+ Q)qqqq  @
+Q)    qq @
+Q)    qq @
+Q)  qq q @
+Q)   qq  @
+ Q)qqq q @
+         @
+         @@
+R)rrrrr  @
+R)    rr @
+R)  rrr  @
+R) rr    @
+R)   rr  @
+R)    rr @
+         @
+         @@
+ S)ssss  @
+S)    ss @
+ S)ss    @
+     S)  @
+S)    ss @
+ S)ssss  @
+         @
+         @@
+T)tttttt @
+   T)    @
+   T)    @
+   T)    @
+   T)    @
+   T)    @
+         @
+         @@
+U)    uu @
+U)    uu @
+U)    uu @
+U)    uu @
+U)    uu @
+ U)uuuu  @
+         @
+         @@
+V)    vv @
+V)    vv @
+V)    vv @
+ V)  vv  @
+  V)vv   @
+   V)    @
+         @
+         @@
+W)      ww @
+W)      ww @
+W)  ww  ww @
+W)  ww  ww @
+W)  ww  ww @
+ W)ww www  @
+           @
+           @@
+X)    xx @
+ X)  xx  @
+  X)xx   @
+  X)xx   @
+ X)  xx  @
+X)    xx @
+         @
+         @@
+Y)    yy @
+ Y)  yy  @
+  Y)yy   @
+   Y)    @
+   Y)    @
+   Y)    @
+         @
+         @@
+Z)zzzzzz @
+      Z) @
+    Z)   @
+   Z)    @
+ Z)      @
+Z)zzzzzz @
+         @
+         @@
+[){{ @
+[)   @
+[)   @
+[)   @
+[)   @
+[){{ @
+     @
+     @@
+\\)|      @
+ \\)|     @
+  \\)|    @
+   \\)|   @
+    \\)|  @
+     \\)| @
+         @
+         @@
+])}} @
+  ]) @
+  ]) @
+  ]) @
+  ]) @
+])}} @
+     @
+     @@
+  **   @
+##  ## @
+       @
+       @
+       @
+       @
+       @
+       @@
+        @
+        @
+        @
+        @
+        @
+####### @
+        @
+        @@
+*** @
+##  @
+ ## @
+    @
+    @
+    @
+    @
+    @@
+        @
+        @
+a)AAAA  @
+ a)AAA  @
+a)   A  @
+ a)AAAA @
+        @
+        @@
+b)      @
+b)      @
+b)BBBB  @
+b)   BB @
+b)   BB @
+b)BBBB  @
+        @
+        @@
+        @
+        @
+ c)CCCC @
+c)      @
+c)      @
+ c)CCCC @
+        @
+        @@
+     d) @
+     d) @
+ d)DDDD @
+d)   DD @
+d)   DD @
+ d)DDDD @
+        @
+        @@
+        @
+        @
+e)EEEEE @
+e)EEEE  @
+e)      @
+ e)EEEE @
+        @
+        @@
+ f)FFF @
+f)     @
+f)FFF  @
+f)     @
+f)     @
+f)     @
+       @
+       @@
+        @
+        @
+ g)GGG  @
+g)   GG @
+g)   GG @
+ g)GGGG @
+     GG @
+g)GGGG  @@
+h)      @
+h)      @
+h)HHHH  @
+h)   HH @
+h)   HH @
+h)   HH @
+        @
+        @@
+## @
+   @
+i) @
+i) @
+i) @
+i) @
+   @
+   @@
+     ## @
+        @
+     j) @
+     j) @
+     j) @
+     j) @
+j)   JJ @
+ j)JJJ  @@
+k)     @
+k)     @
+k)  KK @
+k)KK   @
+k) KK  @
+k)  KK @
+       @
+       @@
+l)L  @
+ l)  @
+ l)  @
+ l)  @
+ l)  @
+l)LL @
+     @
+     @@
+           @
+           @
+ m)MM MMM  @
+m)  MM  MM @
+m)  MM  MM @
+m)      MM @
+           @
+           @@
+        @
+        @
+n)NNNN  @
+n)   NN @
+n)   NN @
+n)   NN @
+        @
+        @@
+        @
+        @
+ o)OOO  @
+o)   OO @
+o)   OO @
+ o)OOO  @
+        @
+        @@
+        @
+        @
+p)PPPP  @
+p)   PP @
+p)   PP @
+p)PPPP  @
+p)      @
+p)      @@
+        @
+        @
+ q)QQQ  @
+q)   QQ @
+q)   QQ @
+ q)QQQQ @
+     q) @
+     q) @@
+        @
+        @
+ r)RRR  @
+r)   RR @
+r)      @
+r)      @
+        @
+        @@
+        @
+        @
+ s)SSSS @
+s)SSSS  @
+     s) @
+s)SSSS  @
+        @
+        @@
+  t)   @
+t)tTTT @
+  t)   @
+  t)   @
+  t)   @
+  t)T  @
+       @
+       @@
+        @
+        @
+u)   UU @
+u)   UU @
+u)   UU @
+ u)UUU  @
+        @
+        @@
+         @
+         @
+v)    VV @
+ v)  VV  @
+  v)VV   @
+   v)    @
+         @
+         @@
+           @
+           @
+w)      WW @
+w)  WW  WW @
+w)  WW  WW @
+ w)WW WWW  @
+           @
+           @@
+        @
+        @
+x)   XX @
+  x)X   @
+  x)X   @
+x)   XX @
+        @
+        @@
+        @
+        @
+y)   YY @
+y)   YY @
+y)   YY @
+ y)YYYY @
+     y) @
+y)YYYY  @@
+        @
+        @
+z)ZZZZZ @
+    z)  @
+  z)    @
+z)ZZZZZ @
+        @
+        @@
+ {)[[[ @
+  {)   @
+[{)    @
+  {)   @
+ {)    @
+ {)[[[ @
+       @
+       @@
+|)\\ @
+|)\\ @
+|)\\ @
+|)\\ @
+|)\\ @
+|)\\ @
+    @
+    @@
+})]]]  @
+  })   @
+   })] @
+  })   @
+   })  @
+})]]]  @
+       @
+       @@
+        @
+_-\`-_-\` @
+        @
+        @
+        @
+        @
+        @
+        @@
+@
+@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@
+@
+@@
+@
+@
+@
+@
+@
+@
+@
+@@
+     \\    /      @
+  , . ><>< . ,   @
+  \\\\  /..\\  //   @
+,  \\\\ \\__/ //  , @
+\\\\  \\\\    //  // @
+ \\\\  \\\\__//  //  @
+  \\\\__\\__/__//   @
+    ~~~~~~~~     @@
+@
+@
+@
+@
+@
+@
+@
+@@
+ ####  ####  @
+##...##...## @
+#T........C# @
+ #A......H#  @
+  #N....R#   @
+   #J..I#    @
+    #AS#     @
+     ##      @@
+`

.pnpm-store/v3/files/b4/5bf525203ffd05bc6bfed77c7ab48479fee8c18c7cb9b1e0bb0e42fd8212e807a2864f0883b14b32c83c1659572f90efe90caa1a4826eec69f08c3370fe960

@@ -0,0 +1,709 @@
+let parser = require('postcss-value-parser')
+
+let Value = require('./value')
+let insertAreas = require('./hacks/grid-utils').insertAreas
+
+const OLD_LINEAR = /(^|[^-])linear-gradient\(\s*(top|left|right|bottom)/i
+const OLD_RADIAL = /(^|[^-])radial-gradient\(\s*\d+(\w*|%)\s+\d+(\w*|%)\s*,/i
+const IGNORE_NEXT = /(!\s*)?autoprefixer:\s*ignore\s+next/i
+const GRID_REGEX = /(!\s*)?autoprefixer\s*grid:\s*(on|off|(no-)?autoplace)/i
+
+const SIZES = [
+  'width',
+  'height',
+  'min-width',
+  'max-width',
+  'min-height',
+  'max-height',
+  'inline-size',
+  'min-inline-size',
+  'max-inline-size',
+  'block-size',
+  'min-block-size',
+  'max-block-size'
+]
+
+function hasGridTemplate(decl) {
+  return decl.parent.some(
+    i => i.prop === 'grid-template' || i.prop === 'grid-template-areas'
+  )
+}
+
+function hasRowsAndColumns(decl) {
+  let hasRows = decl.parent.some(i => i.prop === 'grid-template-rows')
+  let hasColumns = decl.parent.some(i => i.prop === 'grid-template-columns')
+  return hasRows && hasColumns
+}
+
+class Processor {
+  constructor(prefixes) {
+    this.prefixes = prefixes
+  }
+
+  /**
+   * Add necessary prefixes
+   */
+  add(css, result) {
+    // At-rules
+    let resolution = this.prefixes.add['@resolution']
+    let keyframes = this.prefixes.add['@keyframes']
+    let viewport = this.prefixes.add['@viewport']
+    let supports = this.prefixes.add['@supports']
+
+    css.walkAtRules(rule => {
+      if (rule.name === 'keyframes') {
+        if (!this.disabled(rule, result)) {
+          return keyframes && keyframes.process(rule)
+        }
+      } else if (rule.name === 'viewport') {
+        if (!this.disabled(rule, result)) {
+          return viewport && viewport.process(rule)
+        }
+      } else if (rule.name === 'supports') {
+        if (
+          this.prefixes.options.supports !== false &&
+          !this.disabled(rule, result)
+        ) {
+          return supports.process(rule)
+        }
+      } else if (rule.name === 'media' && rule.params.includes('-resolution')) {
+        if (!this.disabled(rule, result)) {
+          return resolution && resolution.process(rule)
+        }
+      }
+
+      return undefined
+    })
+
+    // Selectors
+    css.walkRules(rule => {
+      if (this.disabled(rule, result)) return undefined
+
+      return this.prefixes.add.selectors.map(selector => {
+        return selector.process(rule, result)
+      })
+    })
+
+    function insideGrid(decl) {
+      return decl.parent.nodes.some(node => {
+        if (node.type !== 'decl') return false
+        let displayGrid =
+          node.prop === 'display' && /(inline-)?grid/.test(node.value)
+        let gridTemplate = node.prop.startsWith('grid-template')
+        let gridGap = /^grid-([A-z]+-)?gap/.test(node.prop)
+        return displayGrid || gridTemplate || gridGap
+      })
+    }
+
+    let gridPrefixes =
+      this.gridStatus(css, result) &&
+      this.prefixes.add['grid-area'] &&
+      this.prefixes.add['grid-area'].prefixes
+
+    css.walkDecls(decl => {
+      if (this.disabledDecl(decl, result)) return undefined
+
+      let parent = decl.parent
+      let prop = decl.prop
+      let value = decl.value
+
+      if (prop === 'color-adjust') {
+        if (parent.every(i => i.prop !== 'print-color-adjust')) {
+          result.warn(
+            'Replace color-adjust to print-color-adjust. ' +
+              'The color-adjust shorthand is currently deprecated.',
+            { node: decl }
+          )
+        }
+      } else if (prop === 'grid-row-span') {
+        result.warn(
+          'grid-row-span is not part of final Grid Layout. Use grid-row.',
+          { node: decl }
+        )
+        return undefined
+      } else if (prop === 'grid-column-span') {
+        result.warn(
+          'grid-column-span is not part of final Grid Layout. Use grid-column.',
+          { node: decl }
+        )
+        return undefined
+      } else if (prop === 'display' && value === 'box') {
+        result.warn(
+          'You should write display: flex by final spec ' +
+            'instead of display: box',
+          { node: decl }
+        )
+        return undefined
+      } else if (prop === 'text-emphasis-position') {
+        if (value === 'under' || value === 'over') {
+          result.warn(
+            'You should use 2 values for text-emphasis-position ' +
+              'For example, `under left` instead of just `under`.',
+            { node: decl }
+          )
+        }
+      } else if (prop === 'text-decoration-skip' && value === 'ink') {
+        result.warn(
+          'Replace text-decoration-skip: ink to ' +
+            'text-decoration-skip-ink: auto, because spec had been changed',
+          { node: decl }
+        )
+      } else {
+        if (gridPrefixes && this.gridStatus(decl, result)) {
+          if (decl.value === 'subgrid') {
+            result.warn('IE does not support subgrid', { node: decl })
+          }
+          if (/^(align|justify|place)-items$/.test(prop) && insideGrid(decl)) {
+            let fixed = prop.replace('-items', '-self')
+            result.warn(
+              `IE does not support ${prop} on grid containers. ` +
+                `Try using ${fixed} on child elements instead: ` +
+                `${decl.parent.selector} > * { ${fixed}: ${decl.value} }`,
+              { node: decl }
+            )
+          } else if (
+            /^(align|justify|place)-content$/.test(prop) &&
+            insideGrid(decl)
+          ) {
+            result.warn(`IE does not support ${decl.prop} on grid containers`, {
+              node: decl
+            })
+          } else if (prop === 'display' && decl.value === 'contents') {
+            result.warn(
+              'Please do not use display: contents; ' +
+                'if you have grid setting enabled',
+              { node: decl }
+            )
+            return undefined
+          } else if (decl.prop === 'grid-gap') {
+            let status = this.gridStatus(decl, result)
+            if (
+              status === 'autoplace' &&
+              !hasRowsAndColumns(decl) &&
+              !hasGridTemplate(decl)
+            ) {
+              result.warn(
+                'grid-gap only works if grid-template(-areas) is being ' +
+                  'used or both rows and columns have been declared ' +
+                  'and cells have not been manually ' +
+                  'placed inside the explicit grid',
+                { node: decl }
+              )
+            } else if (
+              (status === true || status === 'no-autoplace') &&
+              !hasGridTemplate(decl)
+            ) {
+              result.warn(
+                'grid-gap only works if grid-template(-areas) is being used',
+                { node: decl }
+              )
+            }
+          } else if (prop === 'grid-auto-columns') {
+            result.warn('grid-auto-columns is not supported by IE', {
+              node: decl
+            })
+            return undefined
+          } else if (prop === 'grid-auto-rows') {
+            result.warn('grid-auto-rows is not supported by IE', { node: decl })
+            return undefined
+          } else if (prop === 'grid-auto-flow') {
+            let hasRows = parent.some(i => i.prop === 'grid-template-rows')
+            let hasCols = parent.some(i => i.prop === 'grid-template-columns')
+
+            if (hasGridTemplate(decl)) {
+              result.warn('grid-auto-flow is not supported by IE', {
+                node: decl
+              })
+            } else if (value.includes('dense')) {
+              result.warn('grid-auto-flow: dense is not supported by IE', {
+                node: decl
+              })
+            } else if (!hasRows && !hasCols) {
+              result.warn(
+                'grid-auto-flow works only if grid-template-rows and ' +
+                  'grid-template-columns are present in the same rule',
+                { node: decl }
+              )
+            }
+            return undefined
+          } else if (value.includes('auto-fit')) {
+            result.warn('auto-fit value is not supported by IE', {
+              node: decl,
+              word: 'auto-fit'
+            })
+            return undefined
+          } else if (value.includes('auto-fill')) {
+            result.warn('auto-fill value is not supported by IE', {
+              node: decl,
+              word: 'auto-fill'
+            })
+            return undefined
+          } else if (prop.startsWith('grid-template') && value.includes('[')) {
+            result.warn(
+              'Autoprefixer currently does not support line names. ' +
+                'Try using grid-template-areas instead.',
+              { node: decl, word: '[' }
+            )
+          }
+        }
+        if (value.includes('radial-gradient')) {
+          if (OLD_RADIAL.test(decl.value)) {
+            result.warn(
+              'Gradient has outdated direction syntax. ' +
+                'New syntax is like `closest-side at 0 0` ' +
+                'instead of `0 0, closest-side`.',
+              { node: decl }
+            )
+          } else {
+            let ast = parser(value)
+
+            for (let i of ast.nodes) {
+              if (i.type === 'function' && i.value === 'radial-gradient') {
+                for (let word of i.nodes) {
+                  if (word.type === 'word') {
+                    if (word.value === 'cover') {
+                      result.warn(
+                        'Gradient has outdated direction syntax. ' +
+                          'Replace `cover` to `farthest-corner`.',
+                        { node: decl }
+                      )
+                    } else if (word.value === 'contain') {
+                      result.warn(
+                        'Gradient has outdated direction syntax. ' +
+                          'Replace `contain` to `closest-side`.',
+                        { node: decl }
+                      )
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (value.includes('linear-gradient')) {
+          if (OLD_LINEAR.test(value)) {
+            result.warn(
+              'Gradient has outdated direction syntax. ' +
+                'New syntax is like `to left` instead of `right`.',
+              { node: decl }
+            )
+          }
+        }
+      }
+
+      if (SIZES.includes(decl.prop)) {
+        if (!decl.value.includes('-fill-available')) {
+          if (decl.value.includes('fill-available')) {
+            result.warn(
+              'Replace fill-available to stretch, ' +
+                'because spec had been changed',
+              { node: decl }
+            )
+          } else if (decl.value.includes('fill')) {
+            let ast = parser(value)
+            if (ast.nodes.some(i => i.type === 'word' && i.value === 'fill')) {
+              result.warn(
+                'Replace fill to stretch, because spec had been changed',
+                { node: decl }
+              )
+            }
+          }
+        }
+      }
+
+      let prefixer
+
+      if (decl.prop === 'transition' || decl.prop === 'transition-property') {
+        // Transition
+        return this.prefixes.transition.add(decl, result)
+      } else if (decl.prop === 'align-self') {
+        // align-self flexbox or grid
+        let display = this.displayType(decl)
+        if (display !== 'grid' && this.prefixes.options.flexbox !== false) {
+          prefixer = this.prefixes.add['align-self']
+          if (prefixer && prefixer.prefixes) {
+            prefixer.process(decl)
+          }
+        }
+        if (this.gridStatus(decl, result) !== false) {
+          prefixer = this.prefixes.add['grid-row-align']
+          if (prefixer && prefixer.prefixes) {
+            return prefixer.process(decl, result)
+          }
+        }
+      } else if (decl.prop === 'justify-self') {
+        // justify-self flexbox or grid
+        if (this.gridStatus(decl, result) !== false) {
+          prefixer = this.prefixes.add['grid-column-align']
+          if (prefixer && prefixer.prefixes) {
+            return prefixer.process(decl, result)
+          }
+        }
+      } else if (decl.prop === 'place-self') {
+        prefixer = this.prefixes.add['place-self']
+        if (
+          prefixer &&
+          prefixer.prefixes &&
+          this.gridStatus(decl, result) !== false
+        ) {
+          return prefixer.process(decl, result)
+        }
+      } else {
+        // Properties
+        prefixer = this.prefixes.add[decl.prop]
+        if (prefixer && prefixer.prefixes) {
+          return prefixer.process(decl, result)
+        }
+      }
+
+      return undefined
+    })
+
+    // Insert grid-area prefixes. We need to be able to store the different
+    // rules as a data and hack API is not enough for this
+    if (this.gridStatus(css, result)) {
+      insertAreas(css, this.disabled)
+    }
+
+    // Values
+    return css.walkDecls(decl => {
+      if (this.disabledValue(decl, result)) return
+
+      let unprefixed = this.prefixes.unprefixed(decl.prop)
+      let list = this.prefixes.values('add', unprefixed)
+      if (Array.isArray(list)) {
+        for (let value of list) {
+          if (value.process) value.process(decl, result)
+        }
+      }
+      Value.save(this.prefixes, decl)
+    })
+  }
+
+  /**
+   * Check for control comment and global options
+   */
+  disabled(node, result) {
+    if (!node) return false
+
+    if (node._autoprefixerDisabled !== undefined) {
+      return node._autoprefixerDisabled
+    }
+
+    if (node.parent) {
+      let p = node.prev()
+      if (p && p.type === 'comment' && IGNORE_NEXT.test(p.text)) {
+        node._autoprefixerDisabled = true
+        node._autoprefixerSelfDisabled = true
+        return true
+      }
+    }
+
+    let value = null
+    if (node.nodes) {
+      let status
+      node.each(i => {
+        if (i.type !== 'comment') return
+        if (/(!\s*)?autoprefixer:\s*(off|on)/i.test(i.text)) {
+          if (typeof status !== 'undefined') {
+            result.warn(
+              'Second Autoprefixer control comment ' +
+                'was ignored. Autoprefixer applies control ' +
+                'comment to whole block, not to next rules.',
+              { node: i }
+            )
+          } else {
+            status = /on/i.test(i.text)
+          }
+        }
+      })
+
+      if (status !== undefined) {
+        value = !status
+      }
+    }
+    if (!node.nodes || value === null) {
+      if (node.parent) {
+        let isParentDisabled = this.disabled(node.parent, result)
+        if (node.parent._autoprefixerSelfDisabled === true) {
+          value = false
+        } else {
+          value = isParentDisabled
+        }
+      } else {
+        value = false
+      }
+    }
+    node._autoprefixerDisabled = value
+    return value
+  }
+
+  /**
+   * Check for grid/flexbox options.
+   */
+  disabledDecl(node, result) {
+    if (node.type === 'decl' && this.gridStatus(node, result) === false) {
+      if (node.prop.includes('grid') || node.prop === 'justify-items') {
+        return true
+      }
+    }
+    if (node.type === 'decl' && this.prefixes.options.flexbox === false) {
+      let other = ['order', 'justify-content', 'align-items', 'align-content']
+      if (node.prop.includes('flex') || other.includes(node.prop)) {
+        return true
+      }
+    }
+
+    return this.disabled(node, result)
+  }
+
+  /**
+   * Check for grid/flexbox options.
+   */
+  disabledValue(node, result) {
+    if (this.gridStatus(node, result) === false && node.type === 'decl') {
+      if (node.prop === 'display' && node.value.includes('grid')) {
+        return true
+      }
+    }
+    if (this.prefixes.options.flexbox === false && node.type === 'decl') {
+      if (node.prop === 'display' && node.value.includes('flex')) {
+        return true
+      }
+    }
+    if (node.type === 'decl' && node.prop === 'content') {
+      return true
+    }
+
+    return this.disabled(node, result)
+  }
+
+  /**
+   * Is it flebox or grid rule
+   */
+  displayType(decl) {
+    for (let i of decl.parent.nodes) {
+      if (i.prop !== 'display') {
+        continue
+      }
+
+      if (i.value.includes('flex')) {
+        return 'flex'
+      }
+
+      if (i.value.includes('grid')) {
+        return 'grid'
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Set grid option via control comment
+   */
+  gridStatus(node, result) {
+    if (!node) return false
+
+    if (node._autoprefixerGridStatus !== undefined) {
+      return node._autoprefixerGridStatus
+    }
+
+    let value = null
+    if (node.nodes) {
+      let status
+      node.each(i => {
+        if (i.type !== 'comment') return
+        if (GRID_REGEX.test(i.text)) {
+          let hasAutoplace = /:\s*autoplace/i.test(i.text)
+          let noAutoplace = /no-autoplace/i.test(i.text)
+          if (typeof status !== 'undefined') {
+            result.warn(
+              'Second Autoprefixer grid control comment was ' +
+                'ignored. Autoprefixer applies control comments to the whole ' +
+                'block, not to the next rules.',
+              { node: i }
+            )
+          } else if (hasAutoplace) {
+            status = 'autoplace'
+          } else if (noAutoplace) {
+            status = true
+          } else {
+            status = /on/i.test(i.text)
+          }
+        }
+      })
+
+      if (status !== undefined) {
+        value = status
+      }
+    }
+
+    if (node.type === 'atrule' && node.name === 'supports') {
+      let params = node.params
+      if (params.includes('grid') && params.includes('auto')) {
+        value = false
+      }
+    }
+
+    if (!node.nodes || value === null) {
+      if (node.parent) {
+        let isParentGrid = this.gridStatus(node.parent, result)
+        if (node.parent._autoprefixerSelfDisabled === true) {
+          value = false
+        } else {
+          value = isParentGrid
+        }
+      } else if (typeof this.prefixes.options.grid !== 'undefined') {
+        value = this.prefixes.options.grid
+      } else if (typeof process.env.AUTOPREFIXER_GRID !== 'undefined') {
+        if (process.env.AUTOPREFIXER_GRID === 'autoplace') {
+          value = 'autoplace'
+        } else {
+          value = true
+        }
+      } else {
+        value = false
+      }
+    }
+
+    node._autoprefixerGridStatus = value
+    return value
+  }
+
+  /**
+   * Normalize spaces in cascade declaration group
+   */
+  reduceSpaces(decl) {
+    let stop = false
+    this.prefixes.group(decl).up(() => {
+      stop = true
+      return true
+    })
+    if (stop) {
+      return
+    }
+
+    let parts = decl.raw('before').split('\n')
+    let prevMin = parts[parts.length - 1].length
+    let diff = false
+
+    this.prefixes.group(decl).down(other => {
+      parts = other.raw('before').split('\n')
+      let last = parts.length - 1
+
+      if (parts[last].length > prevMin) {
+        if (diff === false) {
+          diff = parts[last].length - prevMin
+        }
+
+        parts[last] = parts[last].slice(0, -diff)
+        other.raws.before = parts.join('\n')
+      }
+    })
+  }
+
+  /**
+   * Remove unnecessary pefixes
+   */
+  remove(css, result) {
+    // At-rules
+    let resolution = this.prefixes.remove['@resolution']
+
+    css.walkAtRules((rule, i) => {
+      if (this.prefixes.remove[`@${rule.name}`]) {
+        if (!this.disabled(rule, result)) {
+          rule.parent.removeChild(i)
+        }
+      } else if (
+        rule.name === 'media' &&
+        rule.params.includes('-resolution') &&
+        resolution
+      ) {
+        resolution.clean(rule)
+      }
+    })
+
+    // Selectors
+    css.walkRules((rule, i) => {
+      if (this.disabled(rule, result)) return
+
+      for (let checker of this.prefixes.remove.selectors) {
+        if (checker.check(rule)) {
+          rule.parent.removeChild(i)
+          return
+        }
+      }
+    })
+
+    return css.walkDecls((decl, i) => {
+      if (this.disabled(decl, result)) return
+
+      let rule = decl.parent
+      let unprefixed = this.prefixes.unprefixed(decl.prop)
+
+      // Transition
+      if (decl.prop === 'transition' || decl.prop === 'transition-property') {
+        this.prefixes.transition.remove(decl)
+      }
+
+      // Properties
+      if (
+        this.prefixes.remove[decl.prop] &&
+        this.prefixes.remove[decl.prop].remove
+      ) {
+        let notHack = this.prefixes.group(decl).down(other => {
+          return this.prefixes.normalize(other.prop) === unprefixed
+        })
+
+        if (unprefixed === 'flex-flow') {
+          notHack = true
+        }
+
+        if (decl.prop === '-webkit-box-orient') {
+          let hacks = { 'flex-direction': true, 'flex-flow': true }
+          if (!decl.parent.some(j => hacks[j.prop])) return
+        }
+
+        if (notHack && !this.withHackValue(decl)) {
+          if (decl.raw('before').includes('\n')) {
+            this.reduceSpaces(decl)
+          }
+          rule.removeChild(i)
+          return
+        }
+      }
+
+      // Values
+      for (let checker of this.prefixes.values('remove', unprefixed)) {
+        if (!checker.check) continue
+        if (!checker.check(decl.value)) continue
+
+        unprefixed = checker.unprefixed
+        let notHack = this.prefixes.group(decl).down(other => {
+          return other.value.includes(unprefixed)
+        })
+
+        if (notHack) {
+          rule.removeChild(i)
+          return
+        }
+      }
+    })
+  }
+
+  /**
+   * Some rare old values, which is not in standard
+   */
+  withHackValue(decl) {
+    return (
+      (decl.prop === '-webkit-background-clip' && decl.value === 'text') ||
+      // Do not remove -webkit-box-orient when -webkit-line-clamp is present.
+      // https://github.com/postcss/autoprefixer/issues/1510
+      (decl.prop === '-webkit-box-orient' &&
+        decl.parent.some(d => d.prop === '-webkit-line-clamp'))
+    )
+  }
+}
+
+module.exports = Processor

.pnpm-store/v3/files/b4/5c93f52a033fdfda408fdeecd06f6d2b5a401dbb72ff774113f8854fd764213adb885e85ea880a224002ea1e258a2078417ff80905a6ff9ec2ab840bd729f5

@@ -0,0 +1,27 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AST"), exports);
+__exportStar(require("./Config"), exports);
+__exportStar(require("./ESLint"), exports);
+__exportStar(require("./Linter"), exports);
+__exportStar(require("./Parser"), exports);
+__exportStar(require("./ParserOptions"), exports);
+__exportStar(require("./Processor"), exports);
+__exportStar(require("./Rule"), exports);
+__exportStar(require("./RuleTester"), exports);
+__exportStar(require("./Scope"), exports);
+__exportStar(require("./SourceCode"), exports);

.pnpm-store/v3/files/b4/5d2afe62562816dce915431fbaa90b0e53e680d537d97ae61b93856488a02363c4860896c89a187587f252da330ecf36e13f72f5c5e2a3bfa670de9ccc0a28

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview disallow use of the Buffer() constructor
+ * @author Teddy Katz
+ * @deprecated in ESLint v7.0.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Node.js rules were moved out of ESLint core.",
+			url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+			deprecatedSince: "7.0.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n",
+					},
+					rule: {
+						name: "no-deprecated-api",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-deprecated-api.md",
+					},
+				},
+			],
+		},
+
+		type: "problem",
+
+		docs: {
+			description: "Disallow use of the `Buffer()` constructor",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-buffer-constructor",
+		},
+
+		schema: [],
+
+		messages: {
+			deprecated:
+				"{{expr}} is deprecated. Use Buffer.from(), Buffer.alloc(), or Buffer.allocUnsafe() instead.",
+		},
+	},
+
+	create(context) {
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			"CallExpression[callee.name='Buffer'], NewExpression[callee.name='Buffer']"(
+				node,
+			) {
+				context.report({
+					node,
+					messageId: "deprecated",
+					data: {
+						expr:
+							node.type === "CallExpression"
+								? "Buffer()"
+								: "new Buffer()",
+					},
+				});
+			},
+		};
+	},
+};

.pnpm-store/v3/files/b4/5f953c39a67dc3e4a9f062b0620864994822deb221cb2c26f8dbd9ffdb18f2bf97ec2ff25185030e40c13ab74d2c0126fa87735416533b2d7b3081ea4f9ec6

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=InjectFromOptions.js.map

.pnpm-store/v3/files/b4/608e88aca4325d18f4981fe74ec0640e0c596648c7da8ed874250d3874dc6cc648781b9b10ed0f53f7011db5a21769a11eae40ff172cd39f48a160031e9879

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jesse Feng
+
+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/v3/files/b4/6379eea0f99ffed384eee59963dad970bab9deaad26833faed3bcdddb23df1859cc44d6708f88ebcfc106b29731cfda8f0de9c138036c871833b9caa8e3d8c

@@ -0,0 +1 @@
+module.exports = require('./keyBy');

.pnpm-store/v3/files/b4/64dead5e83cd9849339f110dc7df712e9547fd5c3de0fef8a83d381692d3e932e7ccf2ab2dcb2dd4ca97abd8048ff7231bd296e25551848d1d22829c6a253f

@@ -0,0 +1,34 @@
+import * as asn1js from "asn1js";
+import { AsnRepeatType } from "./decorators";
+import { AsnPropTypes, AsnTypeTypes } from "./enums";
+import { IAsnConverter, IEmptyConstructor } from "./types";
+export interface IAsnSchemaItem {
+    type: AsnPropTypes | IEmptyConstructor;
+    optional?: boolean;
+    defaultValue?: unknown;
+    context?: number;
+    implicit?: boolean;
+    converter?: IAsnConverter;
+    repeated?: AsnRepeatType;
+    raw?: boolean;
+}
+export interface IAsnSchema {
+    type: AsnTypeTypes;
+    itemType: AsnPropTypes | IEmptyConstructor;
+    items: {
+        [key: string]: IAsnSchemaItem;
+    };
+    schema?: AsnSchemaType;
+}
+export type AsnSchemaType = asn1js.Sequence | asn1js.Set | asn1js.Choice;
+export declare class AsnSchemaStorage {
+    protected items: WeakMap<object, IAsnSchema>;
+    has(target: object): boolean;
+    get(target: IEmptyConstructor, checkSchema: true): IAsnSchema & Required<Pick<IAsnSchema, "schema">>;
+    get(target: IEmptyConstructor, checkSchema?: false): IAsnSchema;
+    cache(target: IEmptyConstructor): void;
+    createDefault(target: object): IAsnSchema;
+    create(target: object, useNames: boolean): AsnSchemaType;
+    set(target: object, schema: IAsnSchema): this;
+    protected findParentSchema(target: object): IAsnSchema | null;
+}

.pnpm-store/v3/files/b4/65638d6e5e9e5a266fb2c4b46cb117f1e4179860718824596f6885421497952aa213a8e492217d83ef076c08f37b0ab32e8e2a84d2c36a5dc5dcc1bcb24cfc

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { type TLiteral } from '../literal/index';
+import { Kind, Hint } from '../symbols/index';
+export type TEnumRecord = Record<TEnumKey, TEnumValue>;
+export type TEnumValue = string | number;
+export type TEnumKey = string;
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+    [Kind]: 'Union';
+    [Hint]: 'Enum';
+    static: T[keyof T];
+    anyOf: TLiteral<T[keyof T]>[];
+}
+/** `[Json]` Creates a Enum type */
+export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

.pnpm-store/v3/files/b4/668e9328649d1a5ee3d95ee6157761bba278602c0165d008377911e144c1bf44e206489a5ecf906eb69246a70e6a82cc0c4403dd4f25d0bb04732764c268d9

@@ -0,0 +1,145 @@
+# Console Control Strings
+
+A library of cross-platform tested terminal/console command strings for
+doing things like color and cursor positioning.  This is a subset of both
+ansi and vt100.  All control codes included work on both Windows & Unix-like
+OSes, except where noted.
+
+## Usage
+
+```js
+var consoleControl = require('console-control-strings')
+
+console.log(consoleControl.color('blue','bgRed', 'bold') + 'hi there' + consoleControl.color('reset'))
+process.stdout.write(consoleControl.goto(75, 10))
+```
+
+## Why Another?
+
+There are tons of libraries similar to this one.  I wanted one that was:
+
+1. Very clear about compatibility goals.
+2. Could emit, for instance, a start color code without an end one.
+3. Returned strings w/o writing to streams.
+4. Was not weighed down with other unrelated baggage.
+
+## Functions
+
+### var code = consoleControl.up(_num = 1_)
+
+Returns the escape sequence to move _num_ lines up.
+
+### var code = consoleControl.down(_num = 1_)
+
+Returns the escape sequence to move _num_ lines down.
+
+### var code = consoleControl.forward(_num = 1_)
+
+Returns the escape sequence to move _num_ lines righ.
+
+### var code = consoleControl.back(_num = 1_)
+
+Returns the escape sequence to move _num_ lines left.
+
+### var code = consoleControl.nextLine(_num = 1_)
+
+Returns the escape sequence to move _num_ lines down and to the beginning of
+the line.
+
+### var code = consoleControl.previousLine(_num = 1_)
+
+Returns the escape sequence to move _num_ lines up and to the beginning of
+the line.
+
+### var code = consoleControl.eraseData()
+
+Returns the escape sequence to erase everything from the current cursor
+position to the bottom right of the screen.  This is line based, so it
+erases the remainder of the current line and all following lines.
+
+### var code = consoleControl.eraseLine()
+
+Returns the escape sequence to erase to the end of the current line.
+
+### var code = consoleControl.goto(_x_, _y_)
+
+Returns the escape sequence to move the cursor to the designated position. 
+Note that the origin is _1, 1_ not _0, 0_.
+
+### var code = consoleControl.gotoSOL()
+
+Returns the escape sequence to move the cursor to the beginning of the
+current line. (That is, it returns a carriage return, `\r`.)
+
+### var code = consoleControl.beep()
+
+Returns the escape sequence to cause the termianl to beep.  (That is, it
+returns unicode character `\x0007`, a Control-G.)
+
+### var code = consoleControl.hideCursor()
+
+Returns the escape sequence to hide the cursor.
+
+### var code = consoleControl.showCursor()
+
+Returns the escape sequence to show the cursor.
+
+### var code = consoleControl.color(_colors = []_)
+
+### var code = consoleControl.color(_color1_, _color2_, _…_, _colorn_)
+
+Returns the escape sequence to set the current terminal display attributes
+(mostly colors).  Arguments can either be a list of attributes or an array
+of attributes.  The difference between passing in an array or list of colors
+and calling `.color` separately for each one, is that in the former case a
+single escape sequence will be produced where as in the latter each change
+will have its own distinct escape sequence.  Each attribute can be one of:
+
+* Reset:
+  * **reset** – Reset all attributes to the terminal default.
+* Styles:
+  * **bold** – Display text as bold.  In some terminals this means using a
+    bold font, in others this means changing the color.  In some it means
+    both.
+  * **italic** – Display text as italic. This is not available in most Windows terminals.
+  * **underline** – Underline text. This is not available in most Windows Terminals.
+  * **inverse** – Invert the foreground and background colors.
+  * **stopBold** – Do not display text as bold.
+  * **stopItalic** – Do not display text as italic.
+  * **stopUnderline** – Do not underline text.
+  * **stopInverse** – Do not invert foreground and background.
+* Colors:
+  * **white**
+  * **black**
+  * **blue**
+  * **cyan**
+  * **green**
+  * **magenta**
+  * **red**
+  * **yellow**
+  * **grey** / **brightBlack**
+  * **brightRed**
+  * **brightGreen**
+  * **brightYellow**
+  * **brightBlue**
+  * **brightMagenta**
+  * **brightCyan**
+  * **brightWhite**
+* Background Colors:
+  * **bgWhite**
+  * **bgBlack**
+  * **bgBlue**
+  * **bgCyan**
+  * **bgGreen**
+  * **bgMagenta**
+  * **bgRed**
+  * **bgYellow**
+  * **bgGrey** / **bgBrightBlack**
+  * **bgBrightRed**
+  * **bgBrightGreen**
+  * **bgBrightYellow**
+  * **bgBrightBlue**
+  * **bgBrightMagenta**
+  * **bgBrightCyan**
+  * **bgBrightWhite**
+

.pnpm-store/v3/files/b4/6aaad11240ad8cd88a6eba041b6409d4fcfe32c7486f60e00a4d60018c6b63b5ffa2d62cefbfaf14b2b9b4d0e13e83ac570354ca237759c40d856394261e58

@@ -0,0 +1 @@
+module.exports={A:{A:{"2":"K D E F A B wC"},B:{"1":"0 1 2 3 4 5 Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I","2":"C L M","4100":"G N O P"},C:{"1":"0 1 2 3 4 5 qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B UC 4B VC 5B 6B 7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC LC Q H R WC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I XC MC YC yC zC","2":"6 7 8 9 xC TC J ZB K D E F A B C L M G N O P aB AB BB CB DB EB FB bB 0C 1C","132":"cB dB eB fB","260":"gB","516":"hB iB jB kB lB mB nB oB pB"},D:{"1":"0 1 2 3 4 5 lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B UC 4B VC 5B 6B 7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC LC Q H R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z GB HB IB JB KB LB MB NB OB PB QB RB SB TB UB VB WB XB YB I XC MC YC","2":"6 7 8 9 J ZB K D E F A B C L M G N O P aB AB BB CB DB EB FB bB cB dB eB fB gB","1028":"hB iB jB","2052":"kB"},E:{"1":"A B C L M G aC NC OC 7C 8C 9C bC cC PC AD QC dC eC fC gC hC BD RC iC jC kC lC mC CD SC nC oC pC qC rC sC tC DD ED","2":"J ZB K D E F 2C ZC 3C 4C 5C 6C"},F:{"1":"0 1 2 3 4 5 DB EB FB bB cB dB eB fB gB hB iB jB kB lB mB nB oB pB qB rB sB tB uB vB wB xB yB zB 0B 1B 2B 3B 4B 5B 6B 7B 8B 9B AC BC CC DC EC FC GC HC IC JC KC LC Q H R WC S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z","2":"6 7 8 F B C G N O P aB FD GD HD ID NC uC JD OC","1028":"9 AB BB","2052":"CB"},G:{"1":"RD SD TD UD VD WD XD YD ZD aD bD cD dD bC cC PC eD QC dC eC fC gC hC fD RC iC jC kC lC mC gD SC nC oC pC qC rC sC tC","2":"E ZC KD vC LD MD ND OD PD QD"},H:{"2":"hD"},I:{"1":"I","2":"TC J iD jD kD lD vC mD nD"},J:{"2":"D A"},K:{"1":"H","2":"A B C NC uC OC"},L:{"1":"I"},M:{"1":"MC"},N:{"2":"A B"},O:{"1":"PC"},P:{"1":"6 7 8 9 J AB BB CB DB EB FB oD pD qD rD sD aC tD uD vD wD xD QC RC SC yD"},Q:{"1":"zD"},R:{"1":"0D"},S:{"1":"1D 2D"}},B:2,C:"Content Security Policy Level 2",D:true};

.pnpm-store/v3/files/b4/6b128e641081fae476445736c407c7b6b4d405e8d9cea3d1239b9fdaf6675aa5d3425bd1e8b7c3a67432b19fd41bd0b1152c8e8d7927b7e7cf8f6ef7a032a5

@@ -0,0 +1,13 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you 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
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export type Orientation = 'horizontal' | 'vertical';

.pnpm-store/v3/files/b4/70490ee4cf76ee1dd0799eb28ad17b371ef675197bda617e6555d1279c087b5f4be47bead435de6bdd45a23b53ed1d7e68a21e97e02452f63ae267f41a15b1

@@ -0,0 +1,20 @@
+let Declaration = require('../declaration')
+let utils = require('../utils')
+
+class BackdropFilter extends Declaration {
+  constructor(name, prefixes, all) {
+    super(name, prefixes, all)
+
+    if (this.prefixes) {
+      this.prefixes = utils.uniq(
+        this.prefixes.map(i => {
+          return i === '-ms-' ? '-webkit-' : i
+        })
+      )
+    }
+  }
+}
+
+BackdropFilter.names = ['backdrop-filter']
+
+module.exports = BackdropFilter

.pnpm-store/v3/files/b4/72c4efd1546a575ea1ce60f706a188572917286c4f39695f78302f6701ca275967f02072489ec1c96d598722c49bc03c87762838276775965a47911793b881

@@ -0,0 +1 @@
+{"mappings":";AAAA,4BAAiB;IAAG,WAAW,CAAC,SAAS,CAAC;AAC1C","sources":["packages/@react-aria/overlays/intl/pt-PT.json"],"sourcesContent":["{\n  \"dismiss\": \"Dispensar\"\n}\n"],"names":[],"version":3,"file":"pt-PT.module.js.map"}

.pnpm-store/v3/files/b4/75c806e29563244b9c59aba3342343d934cc280d88d2b3c3ede0c23ebb9dc677a2e4ee141cc382ba10ea12e58bc77c7ac21e4b8d1b247f8bea7dd53b35c95c

@@ -0,0 +1,16 @@
+var $0a79c0aba9e5ecc6$exports = {};
+$0a79c0aba9e5ecc6$exports = {
+    "ascending": `crescente`,
+    "ascendingSort": (args)=>`classificado pela coluna ${args.columnName} em ordem crescente`,
+    "columnSize": (args)=>`${args.value} pixels`,
+    "descending": `decrescente`,
+    "descendingSort": (args)=>`classificado pela coluna ${args.columnName} em ordem decrescente`,
+    "resizerDescription": `Pressione Enter para come\xe7ar a redimensionar`,
+    "select": `Selecionar`,
+    "selectAll": `Selecionar tudo`,
+    "sortable": `coluna classific\xe1vel`
+};
+
+
+export {$0a79c0aba9e5ecc6$exports as default};
+//# sourceMappingURL=pt-BR.module.js.map

.pnpm-store/v3/files/b4/762f81dc33a6badb19832ae145a4f1768c9615292f2db1ecfeba9b78839878d6d0323eb9b3ee3ae8b08e45e6b871e04f43a964d1fe999f6e05c209fc53da11

@@ -0,0 +1,18 @@
+/**
+ * Escape all magic characters in a glob pattern.
+ *
+ * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * option is used, then characters are escaped by wrapping in `[]`, because
+ * a magic character wrapped in a character class can only be satisfied by
+ * that exact character.  In this mode, `\` is _not_ escaped, because it is
+ * not interpreted as a magic character, but instead as a path separator.
+ */
+export const escape = (s, { windowsPathsNoEscape = false, } = {}) => {
+    // don't need to escape +@! because we escape the parens
+    // that make those magic, and escaping ! as [!] isn't valid,
+    // because [!]] is a valid glob class meaning not ']'.
+    return windowsPathsNoEscape
+        ? s.replace(/[?*()[\]]/g, '[$&]')
+        : s.replace(/[?*()[\]\\]/g, '\\$&');
+};
+//# sourceMappingURL=escape.js.map

.pnpm-store/v3/files/b4/7694b90205e5ec82ca36a42f5e78e046bb570299545c360351f465792d4ff678920c9601fd7ff42433fbb05cb9ab071adc33d6d3b09bdaae27b59196aafbfd

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/errors/index.js",
+  "types": "../build/cjs/errors/index.d.ts"
+}

.pnpm-store/v3/files/b4/77606ccfa30009b7cde1983faec88d4a2ea8760432e4ff5a0ff1bd3adf104ef3b125f61898f41b6ea9ca86ef9fc1dbd8b5561a9f94c2c2ccd87bd7c0263ea2

@@ -0,0 +1,2 @@
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).pako={})}(this,(function(e){"use strict";var t=function(e,t,i,n){for(var a=65535&e|0,r=e>>>16&65535|0,o=0;0!==i;){i-=o=i>2e3?2e3:i;do{r=r+(a=a+t[n++]|0)|0}while(--o);a%=65521,r%=65521}return a|r<<16|0},i=new Uint32Array(function(){for(var e,t=[],i=0;i<256;i++){e=i;for(var n=0;n<8;n++)e=1&e?3988292384^e>>>1:e>>>1;t[i]=e}return t}()),n=function(e,t,n,a){var r=i,o=a+n;e^=-1;for(var s=a;s<o;s++)e=e>>>8^r[255&(e^t[s])];return-1^e},a=16209,r=function(e,t){var i,n,r,o,s,l,f,d,h,c,u,w,b,m,k,_,v,g,p,y,x,E,R,A,Z=e.state;i=e.next_in,R=e.input,n=i+(e.avail_in-5),r=e.next_out,A=e.output,o=r-(t-e.avail_out),s=r+(e.avail_out-257),l=Z.dmax,f=Z.wsize,d=Z.whave,h=Z.wnext,c=Z.window,u=Z.hold,w=Z.bits,b=Z.lencode,m=Z.distcode,k=(1<<Z.lenbits)-1,_=(1<<Z.distbits)-1;e:do{w<15&&(u+=R[i++]<<w,w+=8,u+=R[i++]<<w,w+=8),v=b[u&k];t:for(;;){if(u>>>=g=v>>>24,w-=g,0===(g=v>>>16&255))A[r++]=65535&v;else{if(!(16&g)){if(0==(64&g)){v=b[(65535&v)+(u&(1<<g)-1)];continue t}if(32&g){Z.mode=16191;break e}e.msg="invalid literal/length code",Z.mode=a;break e}p=65535&v,(g&=15)&&(w<g&&(u+=R[i++]<<w,w+=8),p+=u&(1<<g)-1,u>>>=g,w-=g),w<15&&(u+=R[i++]<<w,w+=8,u+=R[i++]<<w,w+=8),v=m[u&_];i:for(;;){if(u>>>=g=v>>>24,w-=g,!(16&(g=v>>>16&255))){if(0==(64&g)){v=m[(65535&v)+(u&(1<<g)-1)];continue i}e.msg="invalid distance code",Z.mode=a;break e}if(y=65535&v,w<(g&=15)&&(u+=R[i++]<<w,(w+=8)<g&&(u+=R[i++]<<w,w+=8)),(y+=u&(1<<g)-1)>l){e.msg="invalid distance too far back",Z.mode=a;break e}if(u>>>=g,w-=g,y>(g=r-o)){if((g=y-g)>d&&Z.sane){e.msg="invalid distance too far back",Z.mode=a;break e}if(x=0,E=c,0===h){if(x+=f-g,g<p){p-=g;do{A[r++]=c[x++]}while(--g);x=r-y,E=A}}else if(h<g){if(x+=f+h-g,(g-=h)<p){p-=g;do{A[r++]=c[x++]}while(--g);if(x=0,h<p){p-=g=h;do{A[r++]=c[x++]}while(--g);x=r-y,E=A}}}else if(x+=h-g,g<p){p-=g;do{A[r++]=c[x++]}while(--g);x=r-y,E=A}for(;p>2;)A[r++]=E[x++],A[r++]=E[x++],A[r++]=E[x++],p-=3;p&&(A[r++]=E[x++],p>1&&(A[r++]=E[x++]))}else{x=r-y;do{A[r++]=A[x++],A[r++]=A[x++],A[r++]=A[x++],p-=3}while(p>2);p&&(A[r++]=A[x++],p>1&&(A[r++]=A[x++]))}break}}break}}while(i<n&&r<s);i-=p=w>>3,u&=(1<<(w-=p<<3))-1,e.next_in=i,e.next_out=r,e.avail_in=i<n?n-i+5:5-(i-n),e.avail_out=r<s?s-r+257:257-(r-s),Z.hold=u,Z.bits=w},o=15,s=new Uint16Array([3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258,0,0]),l=new Uint8Array([16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,20,20,20,20,21,21,21,21,16,72,78]),f=new Uint16Array([1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0]),d=new Uint8Array([16,16,16,16,17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,64,64]),h=function(e,t,i,n,a,r,h,c){var u,w,b,m,k,_,v,g,p,y=c.bits,x=0,E=0,R=0,A=0,Z=0,S=0,T=0,O=0,U=0,D=0,I=null,B=new Uint16Array(16),N=new Uint16Array(16),C=null;for(x=0;x<=o;x++)B[x]=0;for(E=0;E<n;E++)B[t[i+E]]++;for(Z=y,A=o;A>=1&&0===B[A];A--);if(Z>A&&(Z=A),0===A)return a[r++]=20971520,a[r++]=20971520,c.bits=1,0;for(R=1;R<A&&0===B[R];R++);for(Z<R&&(Z=R),O=1,x=1;x<=o;x++)if(O<<=1,(O-=B[x])<0)return-1;if(O>0&&(0===e||1!==A))return-1;for(N[1]=0,x=1;x<o;x++)N[x+1]=N[x]+B[x];for(E=0;E<n;E++)0!==t[i+E]&&(h[N[t[i+E]]++]=E);if(0===e?(I=C=h,_=20):1===e?(I=s,C=l,_=257):(I=f,C=d,_=0),D=0,E=0,x=R,k=r,S=Z,T=0,b=-1,m=(U=1<<Z)-1,1===e&&U>852||2===e&&U>592)return 1;for(;;){v=x-T,h[E]+1<_?(g=0,p=h[E]):h[E]>=_?(g=C[h[E]-_],p=I[h[E]-_]):(g=96,p=0),u=1<<x-T,R=w=1<<S;do{a[k+(D>>T)+(w-=u)]=v<<24|g<<16|p|0}while(0!==w);for(u=1<<x-1;D&u;)u>>=1;if(0!==u?(D&=u-1,D+=u):D=0,E++,0==--B[x]){if(x===A)break;x=t[i+h[E]]}if(x>Z&&(D&m)!==b){for(0===T&&(T=Z),k+=R,O=1<<(S=x-T);S+T<A&&!((O-=B[S+T])<=0);)S++,O<<=1;if(U+=1<<S,1===e&&U>852||2===e&&U>592)return 1;a[b=D&m]=Z<<24|S<<16|k-r|0}}return 0!==D&&(a[k+D]=x-T<<24|64<<16|0),c.bits=Z,0},c={Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BLOCK:5,Z_TREES:6,Z_OK:0,Z_STREAM_END:1,Z_NEED_DICT:2,Z_ERRNO:-1,Z_STREAM_ERROR:-2,Z_DATA_ERROR:-3,Z_MEM_ERROR:-4,Z_BUF_ERROR:-5,Z_NO_COMPRESSION:0,Z_BEST_SPEED:1,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1,Z_FILTERED:1,Z_HUFFMAN_ONLY:2,Z_RLE:3,Z_FIXED:4,Z_DEFAULT_STRATEGY:0,Z_BINARY:0,Z_TEXT:1,Z_UNKNOWN:2,Z_DEFLATED:8},u=c.Z_FINISH,w=c.Z_BLOCK,b=c.Z_TREES,m=c.Z_OK,k=c.Z_STREAM_END,_=c.Z_NEED_DICT,v=c.Z_STREAM_ERROR,g=c.Z_DATA_ERROR,p=c.Z_MEM_ERROR,y=c.Z_BUF_ERROR,x=c.Z_DEFLATED,E=16180,R=16190,A=16191,Z=16192,S=16194,T=16199,O=16200,U=16206,D=16209,I=function(e){return(e>>>24&255)+(e>>>8&65280)+((65280&e)<<8)+((255&e)<<24)};function B(){this.strm=null,this.mode=0,this.last=!1,this.wrap=0,this.havedict=!1,this.flags=0,this.dmax=0,this.check=0,this.total=0,this.head=null,this.wbits=0,this.wsize=0,this.whave=0,this.wnext=0,this.window=null,this.hold=0,this.bits=0,this.length=0,this.offset=0,this.extra=0,this.lencode=Line truncated

.pnpm-store/v3/files/b4/778dfc54e0ebd7d0ea4783e8735471d954ca710d1c7eed654d1a77e471da8e5ccb898bba070257e900549a61581e7312127fd030cf4acf85b5d8b62ad8a7d5

@@ -0,0 +1 @@
+{"mappings":";;;AAMA,2BAA2B,CAAC,EAAE,CAAC,SAAS,iBAAe,CAAC,CAAC;IACvD,UAAU,EAAE,CAAC,CAAC;IACd,gDAAgD;IAChD,YAAY,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,kEAAkE;IAClE,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,2HAA2H;IAC3H,4BAA4B,EAAE,OAAO,CAAA;CACtC;AAED,kCAAkC,CAAC,EAAE,CAAC,SAAS,iBAAe,CAAC,CAAC,CAAE,SAAQ,2BAA2B;IACnG,UAAU,EAAE,CAAC,CAAC;IACd,YAAY,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,qBAAqB,CAAC,EAAE,sBAAsB,CAAA;CAC/C;AAED;;GAEG;AACH,6BAA6B,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,iBAAe,CAAC,CAAC,EAAE,KAAK,EAAE,iBAAiB,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CA8F1H;AC1GD,gCAAgC,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAA;CAC/C;AAED,4BAA4B,CAAC,CAAE,YAAW,iBAAgB,CAAC,CAAC;IAC1D,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAa;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC;gBAER,IAAI,EAAE,sBAAsB,CAAC,CAAC;IA6GzC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC;IAInD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,IAAI,gBAAgB,CAAC,GAAG,CAAC;IAIhC,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;IAKlC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;IAKjC,WAAW,IAAI,GAAG,GAAG,IAAI;IAIzB,UAAU,IAAI,GAAG,GAAG,IAAI;IAKxB,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC,GAAG,IAAI;IAIrC,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GAAG,IAAI;IAKnC,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;CAI7C","sources":["packages/@react-stately/grid/src/packages/@react-stately/grid/src/useGridState.ts","packages/@react-stately/grid/src/packages/@react-stately/grid/src/GridCollection.ts","packages/@react-stately/grid/src/packages/@react-stately/grid/src/index.ts","packages/@react-stately/grid/src/index.ts"],"sourcesContent":[null,null,null,"/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nexport {useGridState} from './useGridState';\nexport {GridCollection} from './GridCollection';\n\nexport type {GridStateOptions, GridState} from './useGridState';\n"],"names":[],"version":3,"file":"types.d.ts.map"}

.pnpm-store/v3/files/b4/7a54f01c5e69381dd843b0d9635ef748b5d996d548d05a2982f692d78ea55fa5a159d4d4d66a410232c918f8addbcf4fe19457b9dad53f2f5b33d691b9b1b9

@@ -0,0 +1,8 @@
+// This file is a shim which defers loading the real module until the compile cache is enabled.
+try {
+  const { enableCompileCache } = require("node:module");
+  if (enableCompileCache) {
+    enableCompileCache();
+  }
+} catch {}
+module.exports = require("./_tsc.js");

.pnpm-store/v3/files/b4/7b334d8468f4679b5b2fa9dc6c50e373ee278878d1cc7985b3c40d78b35d74b6f7d0a676565bfb151304740d1e269e657cd950a0fc65094836d78ee537993f

@@ -0,0 +1,60 @@
+'use strict';
+
+var test = require('tape');
+var isDataView = require('../');
+
+var hasToStringTag = require('has-tostringtag/shams')();
+var generators = require('make-generator-function')();
+var arrowFns = require('make-arrow-function').list();
+var forEach = require('for-each');
+var v = require('es-value-fixtures');
+var inspect = require('object-inspect');
+var availableTypedArrays = require('available-typed-arrays')();
+
+test('not DataViews', function (t) {
+	forEach([].concat(
+		// @ts-expect-error TS sucks at [].concat
+		v.primitives,
+		v.objects,
+		function () {},
+		generators,
+		arrowFns,
+		[]
+	), /** @type {(nonDV: unknown) => void} */ function (nonDV) {
+		t.equal(
+			isDataView(nonDV),
+			false,
+			inspect(nonDV) + ' is not a DataView'
+		);
+	});
+
+	forEach(availableTypedArrays, function (typedArray) {
+		var TA = global[typedArray];
+		var ta = new TA(8);
+		t.equal(isDataView(ta), false, inspect(ta) + ' is not a DataView');
+	});
+
+	t.end();
+});
+
+test('@@toStringTag', { skip: !hasToStringTag }, function (t) {
+	forEach(availableTypedArrays, function (typedArray) {
+		// @ts-expect-error
+		var fakeTypedArray = [];
+		// @ts-expect-error
+		fakeTypedArray[Symbol.toStringTag] = typedArray;
+		// @ts-expect-error
+		t.notOk(isDataView(fakeTypedArray), 'faked ' + typedArray + ' is not typed array');
+	});
+
+	t.end();
+});
+
+test('Data Views', { skip: typeof DataView !== 'function' }, function (t) {
+	var ab = new ArrayBuffer(1);
+	var dv = new DataView(ab);
+
+	t.equal(isDataView(dv), true, inspect(dv) + ' is a DataView');
+
+	t.end();
+});

.pnpm-store/v3/files/b4/7c8b753a992c1b0756722a37bb032f4803e4909fa8008fce3605e15dbab63d82567136ed9989ce2afbef6c54281d31ec254c72e4503ae781c0fa5fef617018

@@ -0,0 +1,158 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util_1 = require("../util");
+exports.default = (0, util_1.createRule)({
+    name: 'no-unsafe-type-assertion',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow type assertions that narrow a type',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            unsafeOfAnyTypeAssertion: 'Unsafe assertion from {{type}} detected: consider using type guards or a safer assertion.',
+            unsafeToAnyTypeAssertion: 'Unsafe assertion to {{type}} detected: consider using a more specific type to ensure safety.',
+            unsafeToUnconstrainedTypeAssertion: "Unsafe type assertion: '{{type}}' could be instantiated with an arbitrary type which could be unrelated to the original type.",
+            unsafeTypeAssertion: "Unsafe type assertion: type '{{type}}' is more narrow than the original type.",
+            unsafeTypeAssertionAssignableToConstraint: "Unsafe type assertion: the original type is assignable to the constraint of type '{{type}}', but '{{type}}' could be instantiated with a different subtype of its constraint.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const services = (0, util_1.getParserServices)(context);
+        const checker = services.program.getTypeChecker();
+        function getAnyTypeName(type) {
+            return tsutils.isIntrinsicErrorType(type) ? 'error typed' : '`any`';
+        }
+        function isObjectLiteralType(type) {
+            return (tsutils.isObjectType(type) &&
+                tsutils.isObjectFlagSet(type, ts.ObjectFlags.ObjectLiteral));
+        }
+        function checkExpression(node) {
+            const expressionType = services.getTypeAtLocation(node.expression);
+            const assertedType = services.getTypeAtLocation(node.typeAnnotation);
+            if (expressionType === assertedType) {
+                return;
+            }
+            // handle cases when asserting unknown ==> any.
+            if ((0, util_1.isTypeAnyType)(assertedType) && (0, util_1.isTypeUnknownType)(expressionType)) {
+                context.report({
+                    node,
+                    messageId: 'unsafeToAnyTypeAssertion',
+                    data: {
+                        type: '`any`',
+                    },
+                });
+                return;
+            }
+            const unsafeExpressionAny = (0, util_1.isUnsafeAssignment)(expressionType, assertedType, checker, node.expression);
+            if (unsafeExpressionAny) {
+                context.report({
+                    node,
+                    messageId: 'unsafeOfAnyTypeAssertion',
+                    data: {
+                        type: getAnyTypeName(unsafeExpressionAny.sender),
+                    },
+                });
+                return;
+            }
+            const unsafeAssertedAny = (0, util_1.isUnsafeAssignment)(assertedType, expressionType, checker, node.typeAnnotation);
+            if (unsafeAssertedAny) {
+                context.report({
+                    node,
+                    messageId: 'unsafeToAnyTypeAssertion',
+                    data: {
+                        type: getAnyTypeName(unsafeAssertedAny.sender),
+                    },
+                });
+                return;
+            }
+            // Use the widened type in case of an object literal so `isTypeAssignableTo()`
+            // won't fail on excess property check.
+            const expressionWidenedType = isObjectLiteralType(expressionType)
+                ? checker.getWidenedType(expressionType)
+                : expressionType;
+            const isAssertionSafe = checker.isTypeAssignableTo(expressionWidenedType, assertedType);
+            if (isAssertionSafe) {
+                return;
+            }
+            // Produce a more specific error message when targeting a type parameter
+            if (tsutils.isTypeParameter(assertedType)) {
+                const assertedTypeConstraint = checker.getBaseConstraintOfType(assertedType);
+                if (!assertedTypeConstraint) {
+                    // asserting to an unconstrained type parameter is unsafe
+                    context.report({
+                        node,
+                        messageId: 'unsafeToUnconstrainedTypeAssertion',
+                        data: {
+                            type: checker.typeToString(assertedType),
+                        },
+                    });
+                    return;
+                }
+                // special case message if the original type is assignable to the
+                // constraint of the target type parameter
+                const isAssignableToConstraint = checker.isTypeAssignableTo(expressionWidenedType, assertedTypeConstraint);
+                if (isAssignableToConstraint) {
+                    context.report({
+                        node,
+                        messageId: 'unsafeTypeAssertionAssignableToConstraint',
+                        data: {
+                            type: checker.typeToString(assertedType),
+                        },
+                    });
+                    return;
+                }
+            }
+            // General error message
+            context.report({
+                node,
+                messageId: 'unsafeTypeAssertion',
+                data: {
+                    type: checker.typeToString(assertedType),
+                },
+            });
+        }
+        return {
+            'TSAsExpression, TSTypeAssertion'(node) {
+                checkExpression(node);
+            },
+        };
+    },
+});

.pnpm-store/v3/files/b4/7cb73bdd336af46fc967ae2e91762e5b93d8d4db0c73f6f24f753317bda3d38ae83a698a0fb853c657291b9ef92c7b3b8dc4fabddba5e910b30b18d093bfec

@@ -0,0 +1 @@
+{"version":3,"file":"getExtendedLifecycle.spec.d.ts","sourceRoot":"","sources":["../../../../src/metadata/calculations/getExtendedLifecycle.spec.ts"],"names":[],"mappings":""}

.pnpm-store/v3/files/b4/7cbf01ecc7baf647a21e3ce4c4415db90e8201e30919734e106304eb333c78b594aa92752852616e9b49722cb468e28242f63ec8b64ee5d769b604966b5f97

@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap-segment.d.ts","sourceRoot":"","sources":["../src/sourcemap-segment.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG,MAAM,CAAC;AAC9B,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AACzB,KAAK,YAAY,GAAG,MAAM,CAAC;AAC3B,KAAK,UAAU,GAAG,MAAM,CAAC;AAEzB,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B,MAAM,MAAM,gBAAgB,GACxB,CAAC,eAAe,CAAC,GACjB,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,CAAC,GACzD,CAAC,eAAe,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC,CAAC;AAE5E,eAAO,MAAM,MAAM,IAAI,CAAC;AACxB,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAC"}

.pnpm-store/v3/files/b4/7e78e6287d3d0daaa182720fab4ace5869c73176373f4a00d3d1390e81b19e5d31564541b6d645ab9aa2ac8c4ed6a2f6fac8803c1138d5a664f33e062195aa

@@ -0,0 +1,31 @@
+import { ConsoleAppender, basicLogPrefix } from "base-log-factory";
+import pc from "picocolors";
+import { colors } from "./colors.mjs";
+class ColorfulAppender extends ConsoleAppender {
+  /**
+   * Constructor (构造函数)
+   */
+  constructor(opts = {}) {
+    super(opts.layout);
+    this.name = "colorful";
+    this.colors = opts.colors || colors;
+  }
+  /**
+   * Write log (写入日志)
+   * @param event Log event (日志事件)
+   */
+  write(event) {
+    const { layout } = this;
+    if (layout) {
+      console.log(this.color(layout.format(event), event));
+    } else {
+      console.log(this.color(basicLogPrefix(event, this.dateFormat), event), ...event.message);
+    }
+  }
+  color(str, event) {
+    return pc[this.colors[event.level]](str);
+  }
+}
+export {
+  ColorfulAppender
+};

.pnpm-store/v3/files/b4/7fe563cc23c8bfcb4bd6d6a07d5aea78c2d3cca689f7e0ae1720959f554829b89f112ecbc93faac71e8b0cad7a66ada1e9f710a2ed2c7f3fa657613e500210

@@ -0,0 +1 @@
+{"mappings":"AAAA;;;;;;;;;;CAUC,GAQM,SAAS,0CAA6C,OAAmC;IAC9F,IAAI,CAAC,SACH,OAAO;IAGT,IAAI,wBAAwB;IAC5B,OAAO,CAAC;QACN,IAAI,QAAsB;YACxB,GAAG,CAAC;YACJ;gBACE,EAAE,cAAc;YAClB;YACA;gBACE,OAAO,EAAE,kBAAkB;YAC7B;YACA;gBACE,IAAI,yBAAyB,QAAQ,GAAG,CAAC,QAAQ,KAAK,cACpD,QAAQ,KAAK,CAAC;qBAEd,wBAAwB;YAE5B;YACA;gBACE,wBAAwB;YAC1B;YACA;gBACE,OAAO;YACT;QACF;QAEA,QAAQ;QAER,IAAI,uBACF,EAAE,eAAe;IAErB;AACF","sources":["packages/@react-aria/interactions/src/createEventHandler.ts"],"sourcesContent":["/*\n * Copyright 2020 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {BaseEvent} from '@react-types/shared';\nimport {SyntheticEvent} from 'react';\n\n/**\n * This function wraps a React event handler to make stopPropagation the default, and support continuePropagation instead.\n */\nexport function createEventHandler<T extends SyntheticEvent>(handler?: (e: BaseEvent<T>) => void): ((e: T) => void) | undefined {\n  if (!handler) {\n    return undefined;\n  }\n\n  let shouldStopPropagation = true;\n  return (e: T) => {\n    let event: BaseEvent<T> = {\n      ...e,\n      preventDefault() {\n        e.preventDefault();\n      },\n      isDefaultPrevented() {\n        return e.isDefaultPrevented();\n      },\n      stopPropagation() {\n        if (shouldStopPropagation && process.env.NODE_ENV !== 'production') {\n          console.error('stopPropagation is now the default behavior for events in React Spectrum. You can use continuePropagation() to revert this behavior.');\n        } else {\n          shouldStopPropagation = true;\n        }\n      },\n      continuePropagation() {\n        shouldStopPropagation = false;\n      },\n      isPropagationStopped() {\n        return shouldStopPropagation;\n      }\n    };\n\n    handler(event);\n\n    if (shouldStopPropagation) {\n      e.stopPropagation();\n    }\n  };\n}\n"],"names":[],"version":3,"file":"createEventHandler.module.js.map"}

.pnpm-store/v3/files/b4/816837b924902feb823a12cd0a592c18dee04922a1ec9ab28fe1b43e15bd93067107973989e3e5e2589d67583280d785a4fd6b7e060a1f98dfba4fefa5614a

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('fs');
+const utils = require('../utils');
+const ready = require('get-ready');
+const streamifier = require('streamifier');
+const FlushWritable = require('flushwritable');
+const GzipUncompressStream = require('../gzip').UncompressStream;
+const TarUncompressStream = require('../tar').UncompressStream;
+
+class TgzUncompressStream extends FlushWritable {
+  constructor(opts) {
+    opts = opts || {};
+    super(opts);
+
+    const newOpts = utils.clone(opts);
+    newOpts.source = undefined;
+    this._gzipStream = new GzipUncompressStream(newOpts)
+      .on('error', err => this.emit('error', err));
+
+    const tarStream = new TarUncompressStream(newOpts)
+      .on('finish', () => this.ready(true))
+      .on('entry', this.emit.bind(this, 'entry'))
+      .on('error', err => this.emit('error', err));
+
+    this._gzipStream.pipe(tarStream);
+
+    const sourceType = utils.sourceType(opts.source);
+
+    if (sourceType === 'file') {
+      const stream = fs.createReadStream(opts.source, opts.fs);
+      stream.on('error', err => this.emit('error', err));
+      stream.pipe(this);
+      return;
+    }
+
+    if (sourceType === 'buffer') {
+      const stream = streamifier.createReadStream(opts.source, opts.streamifier);
+      stream.on('error', err => this.emit('error', err));
+      stream.pipe(this);
+      return;
+    }
+
+    if (sourceType === 'stream') {
+      opts.source.on('error', err => this.emit('error', err));
+      opts.source.pipe(this);
+    }
+
+    // else: waiting to be piped
+  }
+
+  _write(chunk, encoding, callback) {
+    this._gzipStream.write(chunk, encoding, callback);
+  }
+
+  _flush(callback) {
+    this._gzipStream.end();
+    this.ready(callback);
+  }
+}
+
+ready.mixin(TgzUncompressStream.prototype);
+
+module.exports = TgzUncompressStream;

.pnpm-store/v3/files/b4/829ee62d81b028a8eb9becedf19f4285c01933c47cad606e76f0026da1db06547c7b77559006ed5781cd086a889f3eb4d17f9db68255e98c8d8792081ac0fa

@@ -0,0 +1,5 @@
+/**
+ * Mixes two colors together. Taken from sass's implementation.
+ */
+declare function mix(color1: string, color2: string, weight: number): string;
+export default mix;

.pnpm-store/v3/files/b4/831461542a8b4d4549843aa041960739d54131af979e786b46175ac2bb327297a45def42f5d10758269833c46cc40abef643476b40c959d6d7c23310fc4371

@@ -0,0 +1,6 @@
+export function enableTableNestedRows(): void;
+export function tableNestedRows(): boolean;
+export function enableShadowDOM(): void;
+export function shadowDOM(): boolean;
+
+//# sourceMappingURL=types.d.ts.map

.pnpm-store/v3/files/b4/8380f372220651d0c0a61a7717bd2b533c7c405155d141b0358e6fc14d62fde85ddadd78d40080103878b41f092248a89bcde7bbe26a904b89681cc3d4ca0b

@@ -0,0 +1,5 @@
+Specifications contains syntax formatters for Xcode 3. These do not appear to be supported yet on Xcode 4. To use these with Xcode 3 please install both the gyp.pbfilespec and gyp.xclangspec files in
+
+~/Library/Application Support/Developer/Shared/Xcode/Specifications/
+
+and restart Xcode.

.pnpm-store/v3/files/b4/86d8b596ee70eb340511aa3c992c84951874bf920c7edd54cf208f2f84469dd60148cb105244fb4da46a7c87b708d63a7c2b298062c0098cd29e242c90275e-index.json

@@ -0,0 +1 @@
+{"name":"fdir","version":"6.5.0","requiresBuild":false,"files":{"LICENSE":{"checkedAt":1794532090541,"integrity":"sha512-U5rzE9frjqsI3sW+naRKNl9+VDSdwurgZXBg8ykONZr5QZPmZQCXcKo/8Vb1jdWMCEdQK3AE1nA4C3tImrXt6Q==","mode":420,"size":1053},"dist/index.cjs":{"checkedAt":1794532090542,"integrity":"sha512-sz4j2lqkYJkMIMFtiPQQi9H7BeQJPQzrcHDRL1Z7XMXfPqPWRBwpDnMKzWZR5/MLbcCRE6CnJR0mm19ov6lhHw==","mode":420,"size":18210},"dist/index.d.cts":{"checkedAt":1794532090542,"integrity":"sha512-zyX4+50T9kOPfLdZu+sWPLG46+FU4/USlHeycEOMp5WWjs52BDpXfXEC83EpfvRyE9dJ5tc7OsQUKyDk7hEQSw==","mode":420,"size":5129},"package.json":{"checkedAt":1794532090542,"integrity":"sha512-v9ANUVe8DXApNbNHfetml+5PzYLKWnoJ31AHfAx59FW0v45/kwFR0G1AmSUMX98s/E834k4UeLLfX38aYaTb0g==","mode":420,"size":2694},"README.md":{"checkedAt":1794532090542,"integrity":"sha512-Z1VOAoOSg89ICzWjmpptdw39X4utJ1L+vOHPKZV0lufronjGJzb0zs47ea/WHXGBnjS11o6ABagPIv3pC5HNZQ==","mode":420,"size":3851},"dist/index.mjs":{"checkedAt":1794532090542,"integrity":"sha512-5CXwQxN6C3ctAh8LPaW7C5tLju6IvmaZTdRiOb1C6RMCTN7MsOLwCAsnrKmFxxZoTfNLyzpRNM8t69wBYqGGuA==","mode":420,"size":17225},"dist/index.d.mts":{"checkedAt":1794532090542,"integrity":"sha512-zyX4+50T9kOPfLdZu+sWPLG46+FU4/USlHeycEOMp5WWjs52BDpXfXEC83EpfvRyE9dJ5tc7OsQUKyDk7hEQSw==","mode":420,"size":5129}}}

.pnpm-store/v3/files/b4/86ff3442673fc68c585e500ba81baf377102f7753fdb9ba47c5e137f897df5ae292bf0ba89c0ab4f07ce7e492def89bb248b0a425efad2bbf5d3682c89435d

@@ -0,0 +1,8 @@
+import {
+  kbd
+} from "../chunk-VX7HAPUO.mjs";
+import "../chunk-UWE6H66T.mjs";
+import "../chunk-GIXI35A3.mjs";
+export {
+  kbd
+};

.pnpm-store/v3/files/b4/8baf8c6af924819714ba290e08f9a516cd3b8478899b9841a57fe1e98f485caf15405505c70fd5ff63e2a1f1ab95c820bdc046c66c7d1324eaecfdcdf9e93b

@@ -0,0 +1,2 @@
+export {gfmTableHtml} from './lib/html.js'
+export {gfmTable} from './lib/syntax.js'

.pnpm-store/v3/files/b4/8bc69bc011ad1723efd058e452aca15aaca11dc6a9b1192c5b8e51131ac7028d75391baaff4ee39d10d7304ef05c888b5704ca55409335e1036fca41c48ca4

@@ -0,0 +1,11 @@
+function _initializer_define_property(target, property, descriptor, context) {
+    if (!descriptor) return;
+
+    Object.defineProperty(target, property, {
+        enumerable: descriptor.enumerable,
+        configurable: descriptor.configurable,
+        writable: descriptor.writable,
+        value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
+    });
+}
+export { _initializer_define_property as _ };

.pnpm-store/v3/files/b4/9297211004e1add20a07620a101236b4652245b300eb91629d2a2c0f3fe53d49d041bb57f30d38e9a62eb228feca1f15f9274d41ee8cc9dcd3c945a460ac8d

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('assignWith', require('../assignWith'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

.pnpm-store/v3/files/b4/945d8dcd01a2cf087262d6f467c44891532dfd4dc982e367dddffdacaa3e990e2ae332d04347ddfbddb43b803e8a6c82efccaccd8a7ddbeaccf124003b4ffe

@@ -0,0 +1,80 @@
+'use strict';
+module.exports = function generate__limitItems(it, $keyword, $ruleType) {
+  var out = ' ';
+  var $lvl = it.level;
+  var $dataLvl = it.dataLevel;
+  var $schema = it.schema[$keyword];
+  var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
+  var $errSchemaPath = it.errSchemaPath + '/' + $keyword;
+  var $breakOnError = !it.opts.allErrors;
+  var $errorKeyword;
+  var $data = 'data' + ($dataLvl || '');
+  var $isData = it.opts.$data && $schema && $schema.$data,
+    $schemaValue;
+  if ($isData) {
+    out += ' var schema' + ($lvl) + ' = ' + (it.util.getData($schema.$data, $dataLvl, it.dataPathArr)) + '; ';
+    $schemaValue = 'schema' + $lvl;
+  } else {
+    $schemaValue = $schema;
+  }
+  if (!($isData || typeof $schema == 'number')) {
+    throw new Error($keyword + ' must be number');
+  }
+  var $op = $keyword == 'maxItems' ? '>' : '<';
+  out += 'if ( ';
+  if ($isData) {
+    out += ' (' + ($schemaValue) + ' !== undefined && typeof ' + ($schemaValue) + ' != \'number\') || ';
+  }
+  out += ' ' + ($data) + '.length ' + ($op) + ' ' + ($schemaValue) + ') { ';
+  var $errorKeyword = $keyword;
+  var $$outStack = $$outStack || [];
+  $$outStack.push(out);
+  out = ''; /* istanbul ignore else */
+  if (it.createErrors !== false) {
+    out += ' { keyword: \'' + ($errorKeyword || '_limitItems') + '\' , dataPath: (dataPath || \'\') + ' + (it.errorPath) + ' , schemaPath: ' + (it.util.toQuotedString($errSchemaPath)) + ' , params: { limit: ' + ($schemaValue) + ' } ';
+    if (it.opts.messages !== false) {
+      out += ' , message: \'should NOT have ';
+      if ($keyword == 'maxItems') {
+        out += 'more';
+      } else {
+        out += 'fewer';
+      }
+      out += ' than ';
+      if ($isData) {
+        out += '\' + ' + ($schemaValue) + ' + \'';
+      } else {
+        out += '' + ($schema);
+      }
+      out += ' items\' ';
+    }
+    if (it.opts.verbose) {
+      out += ' , schema:  ';
+      if ($isData) {
+        out += 'validate.schema' + ($schemaPath);
+      } else {
+        out += '' + ($schema);
+      }
+      out += '         , parentSchema: validate.schema' + (it.schemaPath) + ' , data: ' + ($data) + ' ';
+    }
+    out += ' } ';
+  } else {
+    out += ' {} ';
+  }
+  var __err = out;
+  out = $$outStack.pop();
+  if (!it.compositeRule && $breakOnError) {
+    /* istanbul ignore if */
+    if (it.async) {
+      out += ' throw new ValidationError([' + (__err) + ']); ';
+    } else {
+      out += ' validate.errors = [' + (__err) + ']; return false; ';
+    }
+  } else {
+    out += ' var err = ' + (__err) + ';  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ';
+  }
+  out += '} ';
+  if ($breakOnError) {
+    out += ' else { ';
+  }
+  return out;
+}

.pnpm-store/v3/files/b4/947950307bc5034f7bc355ee81d943f798c6a0966046280d583b92ae75b852859f22ff9a13143a927635f68c3640bae18509f5e97708d068729ad4d2b87c75

@@ -0,0 +1,42 @@
+import { __read, __spreadArray } from "tslib";
+import { useMemo, useRef } from 'react';
+import { isFunction } from '../utils';
+import useMemoizedFn from '../useMemoizedFn';
+import useUpdate from '../useUpdate';
+function useControllableValue(defaultProps, options) {
+    if (options === void 0) { options = {}; }
+    var props = defaultProps !== null && defaultProps !== void 0 ? defaultProps : {};
+    var defaultValue = options.defaultValue, _a = options.defaultValuePropName, defaultValuePropName = _a === void 0 ? 'defaultValue' : _a, _b = options.valuePropName, valuePropName = _b === void 0 ? 'value' : _b, _c = options.trigger, trigger = _c === void 0 ? 'onChange' : _c;
+    var value = props[valuePropName];
+    var isControlled = Object.prototype.hasOwnProperty.call(props, valuePropName);
+    var initialValue = useMemo(function () {
+        if (isControlled) {
+            return value;
+        }
+        if (Object.prototype.hasOwnProperty.call(props, defaultValuePropName)) {
+            return props[defaultValuePropName];
+        }
+        return defaultValue;
+    }, []);
+    var stateRef = useRef(initialValue);
+    if (isControlled) {
+        stateRef.current = value;
+    }
+    var update = useUpdate();
+    function setState(v) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var r = isFunction(v) ? v(stateRef.current) : v;
+        if (!isControlled) {
+            stateRef.current = r;
+            update();
+        }
+        if (props[trigger]) {
+            props[trigger].apply(props, __spreadArray([r], __read(args), false));
+        }
+    }
+    return [stateRef.current, useMemoizedFn(setState)];
+}
+export default useControllableValue;

.pnpm-store/v3/files/b4/9c6288bb261dcf40c756f3de868e6015114d718844338306a86f7951e89eb1c9f7ffa4f3da9b2e5d1b7099ecf9ee2de2bbda341c5a119b05b527c076ab8faf-index.json

@@ -0,0 +1 @@
+{"name":"@img/sharp-libvips-linux-x64","version":"1.2.4","requiresBuild":false,"files":{"lib/libvips-cpp.so.8.17.3":{"checkedAt":1794532124569,"integrity":"sha512-bTLpUluXHvmSXe0OkjGiWuBY3VFXiw0uf9xytwhqIbZ8iBzFct9YeKD7RBJ5SUmCPlfz6vkI1LRxqAFV0IYOFg==","mode":420,"size":16645008},"lib/glib-2.0/include/glibconfig.h":{"checkedAt":1794532124570,"integrity":"sha512-mvYmTp5EUno+frtJwaR6pzE6EieG+s+jktO9iqiQgQhVt0V6POv2bbWnKPU7epm+7+0CBzGHBD9sPgCdr5dxMg==","mode":420,"size":5986},"lib/index.js":{"checkedAt":1794532124570,"integrity":"sha512-gnbnufU5zVY34J5YOScRxwTRqq1P4UNNokFG3F+VnCKGywbjVxdKLY3oFhVw2R6vMReWFJ5F+iUis8CbSY34mw==","mode":420,"size":28},"package.json":{"checkedAt":1794532124570,"integrity":"sha512-YTmjZRH91wDnpQJJEkxw92vczq4GfF4wNdKYl6uYLJehA5GOac2S/2Xv7wCAYr9nxTs0KfU0r6SUVGzo6nHBhA==","mode":420,"size":888},"versions.json":{"checkedAt":1794532124570,"integrity":"sha512-E73p0xocJd37xUKjrn6xOVCrIvRWM8zEuw3ImXBlhlWAz7dLgp1Wgx2DBejPxDkV8FGV3dWO3cl0E8nJekweVA==","mode":420,"size":594},"README.md":{"checkedAt":1794532124570,"integrity":"sha512-4nvqQ+w6snp3WBpZtKpR99if6MgZpWdGUXPp+BgiU8d4rTezleeXTMDw2e4aWNYCKxyi+9A7jPpKvtZygXazzQ==","mode":420,"size":4331}}}

.pnpm-store/v3/files/b4/9d045edf1f74483c3041cee271b9c81389f5ef0f04f4e804c8a5889b51e786debc46ccfba5040e153ca2954cde0afed161a064df9f3dd6e6c0a13ea4e1ee72

@@ -0,0 +1,45 @@
+// LRU cache inspired from hashlru (https://github.com/dominictarr/hashlru/blob/v1.0.4/index.js) but object replaced with Map to improve performance
+function createLruCache(maxCacheSize) {
+  if (maxCacheSize < 1) {
+    return {
+      get: function get() {
+        return undefined;
+      },
+      set: function set() {}
+    };
+  }
+  var cacheSize = 0;
+  var cache = new Map();
+  var previousCache = new Map();
+  function update(key, value) {
+    cache.set(key, value);
+    cacheSize++;
+    if (cacheSize > maxCacheSize) {
+      cacheSize = 0;
+      previousCache = cache;
+      cache = new Map();
+    }
+  }
+  return {
+    get: function get(key) {
+      var value = cache.get(key);
+      if (value !== undefined) {
+        return value;
+      }
+      if ((value = previousCache.get(key)) !== undefined) {
+        update(key, value);
+        return value;
+      }
+    },
+    set: function set(key, value) {
+      if (cache.has(key)) {
+        cache.set(key, value);
+      } else {
+        update(key, value);
+      }
+    }
+  };
+}
+
+export { createLruCache };
+//# sourceMappingURL=lru-cache.mjs.map

.pnpm-store/v3/files/b4/9eb57704417e782dee5e5a327c3f5a47e0033fbdfac5f96d8862ac31f37538a5a2beb70360edbcea2e9ccac3f066f8460b54645d15709f6f3c56a67cdbb193

@@ -0,0 +1,4 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export type MessageId = 'confusingAssign' | 'confusingEqual' | 'confusingOperator' | 'notNeedInAssign' | 'notNeedInEqualTest' | 'notNeedInOperator' | 'wrapUpLeft';
+declare const _default: TSESLint.RuleModule<MessageId, [], import("../../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+export default _default;

.pnpm-store/v3/files/b4/a2410a2404b619074fcbb7a148e59a04d3ed6e3227fb0536b27d8159a1cd20d32921986f08a779e4bb692b46e57d6ae2956eaf8b3f924074e8314364105b12

@@ -0,0 +1,117 @@
+export const xmlReplacer = /["$&'<>\u0080-\uFFFF]/g;
+const xmlCodeMap = new Map([
+    [34, "&quot;"],
+    [38, "&amp;"],
+    [39, "&apos;"],
+    [60, "&lt;"],
+    [62, "&gt;"],
+]);
+// For compatibility with node < 4, we wrap `codePointAt`
+export const getCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+String.prototype.codePointAt == null
+    ? (c, index) => (c.charCodeAt(index) & 64512) === 55296
+        ? (c.charCodeAt(index) - 55296) * 1024 +
+            c.charCodeAt(index + 1) -
+            56320 +
+            65536
+        : c.charCodeAt(index)
+    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+        (input, index) => input.codePointAt(index);
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using XML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `&#xfc;`) will be used.
+ */
+export function encodeXML(input) {
+    let returnValue = "";
+    let lastIndex = 0;
+    let match;
+    while ((match = xmlReplacer.exec(input)) !== null) {
+        const { index } = match;
+        const char = input.charCodeAt(index);
+        const next = xmlCodeMap.get(char);
+        if (next === undefined) {
+            returnValue += `${input.substring(lastIndex, index)}&#x${getCodePoint(input, index).toString(16)};`;
+            // Increase by 1 if we have a surrogate pair
+            lastIndex = xmlReplacer.lastIndex += Number((char & 64512) === 55296);
+        }
+        else {
+            returnValue += input.substring(lastIndex, index) + next;
+            lastIndex = index + 1;
+        }
+    }
+    return returnValue + input.substr(lastIndex);
+}
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using numeric hexadecimal reference (eg. `&#xfc;`).
+ *
+ * Have a look at `escapeUTF8` if you want a more concise output at the expense
+ * of reduced transportability.
+ *
+ * @param data String to escape.
+ */
+export const escape = encodeXML;
+/**
+ * Creates a function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ *
+ * @param regex Regular expression to match characters to escape.
+ * @param map Map of characters to escape to their entities.
+ *
+ * @returns Function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ */
+function getEscaper(regex, map) {
+    return function escape(data) {
+        let match;
+        let lastIndex = 0;
+        let result = "";
+        while ((match = regex.exec(data))) {
+            if (lastIndex !== match.index) {
+                result += data.substring(lastIndex, match.index);
+            }
+            // We know that this character will be in the map.
+            result += map.get(match[0].charCodeAt(0));
+            // Every match will be of length 1
+            lastIndex = match.index + 1;
+        }
+        return result + data.substring(lastIndex);
+    };
+}
+/**
+ * Encodes all characters not valid in XML documents using XML entities.
+ *
+ * Note that the output will be character-set dependent.
+ *
+ * @param data String to escape.
+ */
+export const escapeUTF8 = /* #__PURE__ */ getEscaper(/["&'<>]/g, xmlCodeMap);
+/**
+ * Encodes all characters that have to be escaped in HTML attributes,
+ * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+ *
+ * @param data String to escape.
+ */
+export const escapeAttribute = 
+/* #__PURE__ */ getEscaper(/["&\u00A0]/g, new Map([
+    [34, "&quot;"],
+    [38, "&amp;"],
+    [160, "&nbsp;"],
+]));
+/**
+ * Encodes all characters that have to be escaped in HTML text,
+ * following {@link https://html.spec.whatwg.org/multipage/parsing.html#escapingString}.
+ *
+ * @param data String to escape.
+ */
+export const escapeText = /* #__PURE__ */ getEscaper(/[&<>\u00A0]/g, new Map([
+    [38, "&amp;"],
+    [60, "&lt;"],
+    [62, "&gt;"],
+    [160, "&nbsp;"],
+]));
+//# sourceMappingURL=escape.js.map

.pnpm-store/v3/files/b4/a2bcc7e7dbc47a2faf38c4b8742f34f59151d1cf4f0f5926048c8946d89c3fad7ab032c39a88e415ef46dfcaefac94616d1e71860dd1ba31e1b13b3fd58752

@@ -0,0 +1,90 @@
+# socks examples
+
+## Example for SOCKS 'associate' command
+
+The associate command tells the SOCKS proxy server to establish a UDP relay. The server binds to a new UDP port and communicates the newly opened port back to the origin client. From here, any SOCKS UDP frame packets sent to this special UDP port on the Proxy server will be forwarded to the desired destination, and any responses will be forwarded back to the origin client (you).
+
+This can be used for things such as DNS queries, and other UDP communicates.
+
+**Connection Steps**
+
+1. Client -(associate)-> Proxy (Tells the proxy to create a UDP relay and bind on a new port)
+2. Client <-(port)- Proxy (Tells the origin client which port it opened and is accepting UDP frame packets on)
+
+At this point the proxy is accepting UDP frames on the specified port.
+
+3. Client --(udp frame) -> Proxy -> Destination (The origin client sends a UDP frame to the proxy on the UDP port, and the proxy then forwards it to the destination specified in the UDP frame.)
+4. Client <--(udp frame) <-- Proxy <-- Destination (The destination client responds to the udp packet sent in #3)
+
+## Usage
+
+The 'associate' command can only be used by creating a new SocksClient instance and listening for the 'established' event.
+
+**Note:** UDP packets relayed through the proxy servers are encompassed in a special Socks UDP frame format. SocksClient.createUDPFrame() and SocksClient.parseUDPFrame() create and parse these special UDP packets.
+
+```typescript
+const dgram = require('dgram');
+const SocksClient = require('socks').SocksClient;
+
+// Create a local UDP socket for sending/receiving packets to/from the proxy.
+const udpSocket = dgram.createSocket('udp4');
+udpSocket.bind();
+
+// Listen for incoming UDP packets from the proxy server.
+udpSocket.on('message', (message, rinfo) => {
+  console.log(SocksClient.parseUDPFrame(message));
+  /*
+  { frameNumber: 0,
+    remoteHost: { host: '8.8.8.8', port: 53 }, // The remote host that replied with a UDP packet
+    data: <Buffer 74 65 73 74 0a> // The data
+  }
+  */
+});
+
+const options = {
+  proxy: {
+    host: '104.131.124.203',
+    port: 1081,
+    type: 5
+  },
+
+  // This should be the ip and port of the expected client that will be sending UDP frames to the newly opened UDP port on the server.
+  // Most SOCKS servers accept 0.0.0.0 as a wildcard address to accept UDP frames from any source.
+  destination: {
+    host: '0.0.0.0',
+    port: 0
+  },
+
+  command: 'associate'
+};
+
+const client = new SocksClient(options);
+
+// This event is fired when the SOCKS server has started listening on a new UDP port for UDP relaying.
+client.on('established', info => {
+  console.log(info);
+  /*
+  {
+    socket: <Socket ...>,
+    remoteHost: { // This is the remote port on the SOCKS proxy server to send UDP frame packets to.
+      host: '104.131.124.203',
+      port: 58232
+    }
+  }
+  */
+
+  // Send a udp frame to 8.8.8.8 on port 53 through the proxy.
+  const packet = SocksClient.createUDPFrame({
+    remoteHost: { host: '8.8.8.8', port: 53 },
+    data: Buffer.from('hello') // A DNS lookup in the real world.
+  });
+
+  // Send packet.
+  udpSocket.send(packet, info.remoteHost.port, info.remoteHost.host);
+});
+
+// SOCKS proxy failed to bind.
+client.on('error', () => {
+  // Handle errors
+});
+```

.pnpm-store/v3/files/b4/a4fc283f38231c443eec44bc687cdba5a408f859971562fd72bbb64d2d168c998a8cfa9e1c85a4c7abc9784b086b7f3f1e5158776d517c884b2ab594708741

@@ -0,0 +1,651 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSError = void 0;
+exports.isLogicalOperator = isLogicalOperator;
+exports.isESTreeBinaryOperator = isESTreeBinaryOperator;
+exports.getTextForTokenKind = getTextForTokenKind;
+exports.isESTreeClassMember = isESTreeClassMember;
+exports.hasModifier = hasModifier;
+exports.getLastModifier = getLastModifier;
+exports.isComma = isComma;
+exports.isComment = isComment;
+exports.getBinaryExpressionType = getBinaryExpressionType;
+exports.getLineAndCharacterFor = getLineAndCharacterFor;
+exports.getLocFor = getLocFor;
+exports.canContainDirective = canContainDirective;
+exports.getRange = getRange;
+exports.isJSXToken = isJSXToken;
+exports.getDeclarationKind = getDeclarationKind;
+exports.getTSNodeAccessibility = getTSNodeAccessibility;
+exports.findNextToken = findNextToken;
+exports.findFirstMatchingAncestor = findFirstMatchingAncestor;
+exports.hasJSXAncestor = hasJSXAncestor;
+exports.unescapeStringLiteralText = unescapeStringLiteralText;
+exports.isComputedProperty = isComputedProperty;
+exports.isOptional = isOptional;
+exports.isChainExpression = isChainExpression;
+exports.isChildUnwrappableOptionalChain = isChildUnwrappableOptionalChain;
+exports.getTokenType = getTokenType;
+exports.convertToken = convertToken;
+exports.convertTokens = convertTokens;
+exports.createError = createError;
+exports.nodeHasTokens = nodeHasTokens;
+exports.firstDefined = firstDefined;
+exports.identifierIsThisKeyword = identifierIsThisKeyword;
+exports.isThisIdentifier = isThisIdentifier;
+exports.isThisInTypeQuery = isThisInTypeQuery;
+exports.isValidAssignmentTarget = isValidAssignmentTarget;
+exports.getNamespaceModifiers = getNamespaceModifiers;
+exports.declarationNameToString = declarationNameToString;
+const ts = __importStar(require("typescript"));
+const getModifiers_1 = require("./getModifiers");
+const xhtml_entities_1 = require("./jsx/xhtml-entities");
+const ts_estree_1 = require("./ts-estree");
+const version_check_1 = require("./version-check");
+const isAtLeast50 = version_check_1.typescriptVersionIsAtLeast['5.0'];
+const SyntaxKind = ts.SyntaxKind;
+const LOGICAL_OPERATORS = new Set([
+    SyntaxKind.AmpersandAmpersandToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.QuestionQuestionToken,
+]);
+const ASSIGNMENT_OPERATORS = new Set([
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+]);
+const BINARY_OPERATORS = new Set([
+    SyntaxKind.AmpersandAmpersandToken,
+    SyntaxKind.AmpersandToken,
+    SyntaxKind.AsteriskAsteriskToken,
+    SyntaxKind.AsteriskToken,
+    SyntaxKind.BarBarToken,
+    SyntaxKind.BarToken,
+    SyntaxKind.CaretToken,
+    SyntaxKind.EqualsEqualsEqualsToken,
+    SyntaxKind.EqualsEqualsToken,
+    SyntaxKind.ExclamationEqualsEqualsToken,
+    SyntaxKind.ExclamationEqualsToken,
+    SyntaxKind.GreaterThanEqualsToken,
+    SyntaxKind.GreaterThanGreaterThanGreaterThanToken,
+    SyntaxKind.GreaterThanGreaterThanToken,
+    SyntaxKind.GreaterThanToken,
+    SyntaxKind.InKeyword,
+    SyntaxKind.InstanceOfKeyword,
+    SyntaxKind.LessThanEqualsToken,
+    SyntaxKind.LessThanLessThanToken,
+    SyntaxKind.LessThanToken,
+    SyntaxKind.MinusToken,
+    SyntaxKind.PercentToken,
+    SyntaxKind.PlusToken,
+    SyntaxKind.SlashToken,
+]);
+/**
+ * Returns true if the given ts.Token is the assignment operator
+ */
+function isAssignmentOperator(operator) {
+    return ASSIGNMENT_OPERATORS.has(operator.kind);
+}
+/**
+ * Returns true if the given ts.Token is a logical operator
+ */
+function isLogicalOperator(operator) {
+    return LOGICAL_OPERATORS.has(operator.kind);
+}
+function isESTreeBinaryOperator(operator) {
+    return BINARY_OPERATORS.has(operator.kind);
+}
+/**
+ * Returns the string form of the given TSToken SyntaxKind
+ */
+function getTextForTokenKind(kind) {
+    return ts.tokenToString(kind);
+}
+/**
+ * Returns true if the given ts.Node is a valid ESTree class member
+ */
+function isESTreeClassMember(node) {
+    return node.kind !== SyntaxKind.SemicolonClassElement;
+}
+/**
+ * Checks if a ts.Node has a modifier
+ */
+function hasModifier(modifierKind, node) {
+    const modifiers = (0, getModifiers_1.getModifiers)(node);
+    return modifiers?.some(modifier => modifier.kind === modifierKind) === true;
+}
+/**
+ * Get last last modifier in ast
+ * @returns returns last modifier if present or null
+ */
+function getLastModifier(node) {
+    const modifiers = (0, getModifiers_1.getModifiers)(node);
+    if (modifiers == null) {
+        return null;
+    }
+    return modifiers[modifiers.length - 1] ?? null;
+}
+/**
+ * Returns true if the given ts.Token is a comma
+ */
+function isComma(token) {
+    return token.kind === SyntaxKind.CommaToken;
+}
+/**
+ * Returns true if the given ts.Node is a comment
+ */
+function isComment(node) {
+    return (node.kind === SyntaxKind.SingleLineCommentTrivia ||
+        node.kind === SyntaxKind.MultiLineCommentTrivia);
+}
+/**
+ * Returns true if the given ts.Node is a JSDoc comment
+ */
+function isJSDocComment(node) {
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- SyntaxKind.JSDoc was only added in TS4.7 so we can't use it yet
+    return node.kind === SyntaxKind.JSDocComment;
+}
+/**
+ * Returns the binary expression type of the given ts.Token
+ */
+function getBinaryExpressionType(operator) {
+    if (isAssignmentOperator(operator)) {
+        return {
+            type: ts_estree_1.AST_NODE_TYPES.AssignmentExpression,
+            operator: getTextForTokenKind(operator.kind),
+        };
+    }
+    if (isLogicalOperator(operator)) {
+        return {
+            type: ts_estree_1.AST_NODE_TYPES.LogicalExpression,
+            operator: getTextForTokenKind(operator.kind),
+        };
+    }
+    if (isESTreeBinaryOperator(operator)) {
+        return {
+            type: ts_estree_1.AST_NODE_TYPES.BinaryExpression,
+            operator: getTextForTokenKind(operator.kind),
+        };
+    }
+    throw new Error(`Unexpected binary operator ${ts.tokenToString(operator.kind)}`);
+}
+/**
+ * Returns line and column data for the given positions
+ */
+function getLineAndCharacterFor(pos, ast) {
+    const loc = ast.getLineAndCharacterOfPosition(pos);
+    return {
+        column: loc.character,
+        line: loc.line + 1,
+    };
+}
+/**
+ * Returns line and column data for the given start and end positions,
+ * for the given AST
+ */
+function getLocFor(range, ast) {
+    const [start, end] = range.map(pos => getLineAndCharacterFor(pos, ast));
+    return { end, start };
+}
+/**
+ * Check whatever node can contain directive
+ */
+function canContainDirective(node) {
+    if (node.kind === ts.SyntaxKind.Block) {
+        switch (node.parent.kind) {
+            case ts.SyntaxKind.Constructor:
+            case ts.SyntaxKind.GetAccessor:
+            case ts.SyntaxKind.SetAccessor:
+            case ts.SyntaxKind.ArrowFunction:
+            case ts.SyntaxKind.FunctionExpression:
+            case ts.SyntaxKind.FunctionDeclaration:
+            case ts.SyntaxKind.MethodDeclaration:
+                return true;
+            default:
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Returns range for the given ts.Node
+ */
+function getRange(node, ast) {
+    return [node.getStart(ast), node.getEnd()];
+}
+/**
+ * Returns true if a given ts.Node is a token
+ */
+function isToken(node) {
+    return (node.kind >= SyntaxKind.FirstToken && node.kind <= SyntaxKind.LastToken);
+}
+/**
+ * Returns true if a given ts.Node is a JSX token
+ */
+function isJSXToken(node) {
+    return (node.kind >= SyntaxKind.JsxElement && node.kind <= SyntaxKind.JsxAttribute);
+}
+/**
+ * Returns the declaration kind of the given ts.Node
+ */
+function getDeclarationKind(node) {
+    if (node.flags & ts.NodeFlags.Let) {
+        return 'let';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    if ((node.flags & ts.NodeFlags.AwaitUsing) === ts.NodeFlags.AwaitUsing) {
+        return 'await using';
+    }
+    if (node.flags & ts.NodeFlags.Const) {
+        return 'const';
+    }
+    if (node.flags & ts.NodeFlags.Using) {
+        return 'using';
+    }
+    return 'var';
+}
+/**
+ * Gets a ts.Node's accessibility level
+ */
+function getTSNodeAccessibility(node) {
+    const modifiers = (0, getModifiers_1.getModifiers)(node);
+    if (modifiers == null) {
+        return undefined;
+    }
+    for (const modifier of modifiers) {
+        switch (modifier.kind) {
+            case SyntaxKind.PublicKeyword:
+                return 'public';
+            case SyntaxKind.ProtectedKeyword:
+                return 'protected';
+            case SyntaxKind.PrivateKeyword:
+                return 'private';
+            default:
+                break;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the next token based on the previous one and its parent
+ * Had to copy this from TS instead of using TS's version because theirs doesn't pass the ast to getChildren
+ */
+function findNextToken(previousToken, parent, ast) {
+    return find(parent);
+    function find(n) {
+        if (ts.isToken(n) && n.pos === previousToken.end) {
+            // this is token that starts at the end of previous token - return it
+            return n;
+        }
+        return firstDefined(n.getChildren(ast), (child) => {
+            const shouldDiveInChildNode = 
+            // previous token is enclosed somewhere in the child
+            (child.pos <= previousToken.pos && child.end > previousToken.end) ||
+                // previous token ends exactly at the beginning of child
+                child.pos === previousToken.end;
+            return shouldDiveInChildNode && nodeHasTokens(child, ast)
+                ? find(child)
+                : undefined;
+        });
+    }
+}
+/**
+ * Find the first matching ancestor based on the given predicate function.
+ * @param node The current ts.Node
+ * @param predicate The predicate function to apply to each checked ancestor
+ * @returns a matching parent ts.Node
+ */
+function findFirstMatchingAncestor(node, predicate) {
+    let current = node;
+    while (current) {
+        if (predicate(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/**
+ * Returns true if a given ts.Node has a JSX token within its hierarchy
+ */
+function hasJSXAncestor(node) {
+    return !!findFirstMatchingAncestor(node, isJSXToken);
+}
+/**
+ * Unescape the text content of string literals, e.g. &amp; -> &
+ * @param text The escaped string literal text.
+ * @returns The unescaped string literal text.
+ */
+function unescapeStringLiteralText(text) {
+    return text.replaceAll(/&(?:#\d+|#x[\da-fA-F]+|[0-9a-zA-Z]+);/g, entity => {
+        const item = entity.slice(1, -1);
+        if (item[0] === '#') {
+            const codePoint = item[1] === 'x'
+                ? parseInt(item.slice(2), 16)
+                : parseInt(item.slice(1), 10);
+            return codePoint > 0x10ffff // RangeError: Invalid code point
+                ? entity
+                : String.fromCodePoint(codePoint);
+        }
+        return xhtml_entities_1.xhtmlEntities[item] || entity;
+    });
+}
+/**
+ * Returns true if a given ts.Node is a computed property
+ */
+function isComputedProperty(node) {
+    return node.kind === SyntaxKind.ComputedPropertyName;
+}
+/**
+ * Returns true if a given ts.Node is optional (has QuestionToken)
+ * @param node ts.Node to be checked
+ */
+function isOptional(node) {
+    return !!node.questionToken;
+}
+/**
+ * Returns true if the node is an optional chain node
+ */
+function isChainExpression(node) {
+    return node.type === ts_estree_1.AST_NODE_TYPES.ChainExpression;
+}
+/**
+ * Returns true of the child of property access expression is an optional chain
+ */
+function isChildUnwrappableOptionalChain(node, child) {
+    return (isChainExpression(child) &&
+        // (x?.y).z is semantically different, and as such .z is no longer optional
+        node.expression.kind !== ts.SyntaxKind.ParenthesizedExpression);
+}
+/**
+ * Returns the type of a given ts.Token
+ */
+function getTokenType(token) {
+    if (token.kind === SyntaxKind.NullKeyword) {
+        return ts_estree_1.AST_TOKEN_TYPES.Null;
+    }
+    if (token.kind >= SyntaxKind.FirstKeyword &&
+        token.kind <= SyntaxKind.LastFutureReservedWord) {
+        if (token.kind === SyntaxKind.FalseKeyword ||
+            token.kind === SyntaxKind.TrueKeyword) {
+            return ts_estree_1.AST_TOKEN_TYPES.Boolean;
+        }
+        return ts_estree_1.AST_TOKEN_TYPES.Keyword;
+    }
+    if (token.kind >= SyntaxKind.FirstPunctuation &&
+        token.kind <= SyntaxKind.LastPunctuation) {
+        return ts_estree_1.AST_TOKEN_TYPES.Punctuator;
+    }
+    if (token.kind >= SyntaxKind.NoSubstitutionTemplateLiteral &&
+        token.kind <= SyntaxKind.TemplateTail) {
+        return ts_estree_1.AST_TOKEN_TYPES.Template;
+    }
+    switch (token.kind) {
+        case SyntaxKind.NumericLiteral:
+        case SyntaxKind.BigIntLiteral:
+            return ts_estree_1.AST_TOKEN_TYPES.Numeric;
+        case SyntaxKind.PrivateIdentifier:
+            return ts_estree_1.AST_TOKEN_TYPES.PrivateIdentifier;
+        case SyntaxKind.JsxText:
+            return ts_estree_1.AST_TOKEN_TYPES.JSXText;
+        case SyntaxKind.StringLiteral:
+            // A TypeScript-StringLiteral token with a TypeScript-JsxAttribute or TypeScript-JsxElement parent,
+            // must actually be an ESTree-JSXText token
+            if (token.parent.kind === SyntaxKind.JsxAttribute ||
+                token.parent.kind === SyntaxKind.JsxElement) {
+                return ts_estree_1.AST_TOKEN_TYPES.JSXText;
+            }
+            return ts_estree_1.AST_TOKEN_TYPES.String;
+        case SyntaxKind.RegularExpressionLiteral:
+            return ts_estree_1.AST_TOKEN_TYPES.RegularExpression;
+        case SyntaxKind.Identifier:
+        case SyntaxKind.ConstructorKeyword:
+        case SyntaxKind.GetKeyword:
+        case SyntaxKind.SetKeyword:
+        // intentional fallthrough
+        default:
+    }
+    // Some JSX tokens have to be determined based on their parent
+    if (token.kind === SyntaxKind.Identifier) {
+        if (isJSXToken(token.parent)) {
+            return ts_estree_1.AST_TOKEN_TYPES.JSXIdentifier;
+        }
+        if (token.parent.kind === SyntaxKind.PropertyAccessExpression &&
+            hasJSXAncestor(token)) {
+            return ts_estree_1.AST_TOKEN_TYPES.JSXIdentifier;
+        }
+    }
+    return ts_estree_1.AST_TOKEN_TYPES.Identifier;
+}
+/**
+ * Extends and formats a given ts.Token, for a given AST
+ */
+function convertToken(token, ast) {
+    const start = token.kind === SyntaxKind.JsxText
+        ? token.getFullStart()
+        : token.getStart(ast);
+    const end = token.getEnd();
+    const value = ast.text.slice(start, end);
+    const tokenType = getTokenType(token);
+    const range = [start, end];
+    const loc = getLocFor(range, ast);
+    if (tokenType === ts_estree_1.AST_TOKEN_TYPES.RegularExpression) {
+        return {
+            type: tokenType,
+            loc,
+            range,
+            regex: {
+                flags: value.slice(value.lastIndexOf('/') + 1),
+                pattern: value.slice(1, value.lastIndexOf('/')),
+            },
+            value,
+        };
+    }
+    if (tokenType === ts_estree_1.AST_TOKEN_TYPES.PrivateIdentifier) {
+        return {
+            type: tokenType,
+            loc,
+            range,
+            value: value.slice(1),
+        };
+    }
+    // @ts-expect-error TS is complaining about `value` not being the correct
+    // type but it is
+    return {
+        type: tokenType,
+        loc,
+        range,
+        value,
+    };
+}
+/**
+ * Converts all tokens for the given AST
+ * @param ast the AST object
+ * @returns the converted Tokens
+ */
+function convertTokens(ast) {
+    const result = [];
+    /**
+     * @param node the ts.Node
+     */
+    function walk(node) {
+        // TypeScript generates tokens for types in JSDoc blocks. Comment tokens
+        // and their children should not be walked or added to the resulting tokens list.
+        if (isComment(node) || isJSDocComment(node)) {
+            return;
+        }
+        if (isToken(node) && node.kind !== SyntaxKind.EndOfFileToken) {
+            result.push(convertToken(node, ast));
+        }
+        else {
+            node.getChildren(ast).forEach(walk);
+        }
+    }
+    walk(ast);
+    return result;
+}
+class TSError extends Error {
+    fileName;
+    location;
+    constructor(message, fileName, location) {
+        super(message);
+        this.fileName = fileName;
+        this.location = location;
+        Object.defineProperty(this, 'name', {
+            configurable: true,
+            enumerable: false,
+            value: new.target.name,
+        });
+    }
+    // For old version of ESLint https://github.com/typescript-eslint/typescript-eslint/pull/6556#discussion_r1123237311
+    get index() {
+        return this.location.start.offset;
+    }
+    // https://github.com/eslint/eslint/blob/b09a512107249a4eb19ef5a37b0bd672266eafdb/lib/linter/linter.js#L853
+    get lineNumber() {
+        return this.location.start.line;
+    }
+    // https://github.com/eslint/eslint/blob/b09a512107249a4eb19ef5a37b0bd672266eafdb/lib/linter/linter.js#L854
+    get column() {
+        return this.location.start.column;
+    }
+}
+exports.TSError = TSError;
+function createError(message, ast, startIndex, endIndex = startIndex) {
+    const [start, end] = [startIndex, endIndex].map(offset => {
+        const { character: column, line } = ast.getLineAndCharacterOfPosition(offset);
+        return { column, line: line + 1, offset };
+    });
+    return new TSError(message, ast.fileName, { end, start });
+}
+function nodeHasTokens(n, ast) {
+    // If we have a token or node that has a non-zero width, it must have tokens.
+    // Note: getWidth() does not take trivia into account.
+    return n.kind === SyntaxKind.EndOfFileToken
+        ? !!n.jsDoc
+        : n.getWidth(ast) !== 0;
+}
+/**
+ * Like `forEach`, but suitable for use with numbers and strings (which may be falsy).
+ */
+function firstDefined(array, callback) {
+    // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish
+    if (array === undefined) {
+        return undefined;
+    }
+    for (let i = 0; i < array.length; i++) {
+        const result = callback(array[i], i);
+        // eslint-disable-next-line @typescript-eslint/internal/eqeq-nullish
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    return undefined;
+}
+function identifierIsThisKeyword(id) {
+    return ((isAtLeast50
+        ? ts.identifierToKeywordKind(id)
+        : // @ts-expect-error -- intentional fallback for older TS versions <=4.9
+            id.originalKeywordKind) === SyntaxKind.ThisKeyword);
+}
+function isThisIdentifier(node) {
+    return (!!node &&
+        node.kind === SyntaxKind.Identifier &&
+        identifierIsThisKeyword(node));
+}
+function isThisInTypeQuery(node) {
+    if (!isThisIdentifier(node)) {
+        return false;
+    }
+    while (ts.isQualifiedName(node.parent) && node.parent.left === node) {
+        node = node.parent;
+    }
+    return node.parent.kind === SyntaxKind.TypeQuery;
+}
+function isValidAssignmentTarget(node) {
+    switch (node.kind) {
+        case SyntaxKind.Identifier:
+            return true;
+        case SyntaxKind.PropertyAccessExpression:
+        case SyntaxKind.ElementAccessExpression:
+            if (node.flags & ts.NodeFlags.OptionalChain) {
+                return false;
+            }
+            return true;
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.TypeAssertionExpression:
+        case SyntaxKind.AsExpression:
+        case SyntaxKind.SatisfiesExpression:
+        case SyntaxKind.ExpressionWithTypeArguments:
+        case SyntaxKind.NonNullExpression:
+            return isValidAssignmentTarget(node.expression);
+        default:
+            return false;
+    }
+}
+function getNamespaceModifiers(node) {
+    // For following nested namespaces, use modifiers given to the topmost namespace
+    //   export declare namespace foo.bar.baz {}
+    let modifiers = (0, getModifiers_1.getModifiers)(node);
+    let moduleDeclaration = node;
+    while ((!modifiers || modifiers.length === 0) &&
+        ts.isModuleDeclaration(moduleDeclaration.parent)) {
+        const parentModifiers = (0, getModifiers_1.getModifiers)(moduleDeclaration.parent);
+        if (parentModifiers?.length) {
+            modifiers = parentModifiers;
+        }
+        moduleDeclaration = moduleDeclaration.parent;
+    }
+    return modifiers;
+}
+// `ts.declarationNameToString`
+function declarationNameToString(name, ast) {
+    const text = ast.text.slice(name.pos, name.end).trimStart();
+    return text || '(Missing)';
+}

.pnpm-store/v3/files/b4/a81fe3368381bbbe23b1f9dc40022ef6f44b425795f1084bf7b5fc5c3dfd8a1e22e3bd268a14f06b89e54bed82a4b8bf6746ff08c5c3685b55998c6493dd95

@@ -0,0 +1,5 @@
+var convert = require('./convert'),
+    func = convert('sum', require('../sum'), require('./_falseOptions'));
+
+func.placeholder = require('./placeholder');
+module.exports = func;

.pnpm-store/v3/files/b4/a938341b6d8563011f5cb6790c827585b967ae16843afdb019b803254ac6a12e8a4da9617591f6344d5cf6eb8d533526764e7235b07accfdcbaaf9dbf90d0d

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = extractValueFromObjectExpression;
+
+var _object = require('object.assign');
+
+var _object2 = _interopRequireDefault(_object);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Extractor function for an ObjectExpression type value node.
+ * An object expression is using {}.
+ *
+ * @returns - a representation of the object
+ */
+function extractValueFromObjectExpression(value) {
+  // eslint-disable-next-line global-require
+  var getValue = require('.').default;
+  return value.properties.reduce(function (obj, property) {
+    // Support types: SpreadProperty and ExperimentalSpreadProperty
+    if (/^(?:Experimental)?Spread(?:Property|Element)$/.test(property.type)) {
+      if (property.argument.type === 'ObjectExpression') {
+        return (0, _object2.default)({}, obj, extractValueFromObjectExpression(property.argument));
+      }
+    } else {
+      return (0, _object2.default)({}, obj, _defineProperty({}, getValue(property.key), getValue(property.value)));
+    }
+    return obj;
+  }, {});
+}

.pnpm-store/v3/files/b4/abfedd1800a5fcd50c0e346c9792042dcb90bb3f8f72f7db43cd5fce2acc6728188ad903a11536eda5a71868748b4401161d7bc7513f25f33dcf23488f85d5

@@ -0,0 +1,63 @@
+/**
+ * @import {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'
+ * @import {Options} from 'mdast-util-gfm'
+ * @import {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'
+ */
+
+import {
+  gfmAutolinkLiteralFromMarkdown,
+  gfmAutolinkLiteralToMarkdown
+} from 'mdast-util-gfm-autolink-literal'
+import {
+  gfmFootnoteFromMarkdown,
+  gfmFootnoteToMarkdown
+} from 'mdast-util-gfm-footnote'
+import {
+  gfmStrikethroughFromMarkdown,
+  gfmStrikethroughToMarkdown
+} from 'mdast-util-gfm-strikethrough'
+import {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'
+import {
+  gfmTaskListItemFromMarkdown,
+  gfmTaskListItemToMarkdown
+} from 'mdast-util-gfm-task-list-item'
+
+/**
+ * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink
+ * literals, footnotes, strikethrough, tables, tasklists).
+ *
+ * @returns {Array<FromMarkdownExtension>}
+ *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,
+ *   footnotes, strikethrough, tables, tasklists).
+ */
+export function gfmFromMarkdown() {
+  return [
+    gfmAutolinkLiteralFromMarkdown(),
+    gfmFootnoteFromMarkdown(),
+    gfmStrikethroughFromMarkdown(),
+    gfmTableFromMarkdown(),
+    gfmTaskListItemFromMarkdown()
+  ]
+}
+
+/**
+ * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink
+ * literals, footnotes, strikethrough, tables, tasklists).
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {ToMarkdownExtension}
+ *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,
+ *   footnotes, strikethrough, tables, tasklists).
+ */
+export function gfmToMarkdown(options) {
+  return {
+    extensions: [
+      gfmAutolinkLiteralToMarkdown(),
+      gfmFootnoteToMarkdown(options),
+      gfmStrikethroughToMarkdown(),
+      gfmTableToMarkdown(options),
+      gfmTaskListItemToMarkdown()
+    ]
+  }
+}

.pnpm-store/v3/files/b4/ac9c946ba91e7c9280e318a90f65bbaca562ac88521e38deb9617c394a7f11eebb65f274acff47e0285b5d1621da57777b5b4bb04b73116983859c1487b702

@@ -0,0 +1,2 @@
+import type { LibDefinition } from '../variable';
+export declare const es2021_string: LibDefinition;

.pnpm-store/v3/files/b4/adc63c559b8abbcd82c34ab68f94981fdc46d9fa4d97f2c340fa20aad6e799fa55bb3b289a19b48fff9294cacc4fc35269a70050fcfc26b8eacece6ecf76ff-index.json

@@ -0,0 +1 @@
+{"name":"@typescript-eslint/parser","version":"8.46.4","requiresBuild":false,"files":{"LICENSE":{"checkedAt":1794532098054,"integrity":"sha512-t0z/UCQ+RY4AylIo7v6ZCtzCdS9pMnC0+yB0VQa2A+1S+oV4noJtM9o2SOJfDVq7GqTVK4GsuGR2QO4Nb/K7kw==","mode":420,"size":1097},"dist/index.js":{"checkedAt":1794532098054,"integrity":"sha512-NbyO9YS2b/3p9ErdB+0fUAxIsslCm5o2fI3p9KaUd25fhKQbhoOeLYvJf5PfAadDmcXRV+9pNIcjBwM7Nlob5w==","mode":420,"size":1390},"dist/parser.js":{"checkedAt":1794532098054,"integrity":"sha512-rmob8xsJAdIhm6RUMvJWiSogyHGSD0gc5VbuiQ3UOEPp96lm7gswVVerJQU6T/IzC649Uz2/KzfPjPyK7SVYUw==","mode":420,"size":6280},"package.json":{"checkedAt":1794532098054,"integrity":"sha512-/M0ffe+nZch5u3JeOWAm1lhq47ic9EU7BlmsBG6dGsOqOw1W3E4IUcuhUSa164AgT83N3nkI8BEQwc6JquYObw==","mode":420,"size":1936},"README.md":{"checkedAt":1794532098054,"integrity":"sha512-kYZ5tX9R62L0+EmZz5LNdsD2nrrOgatFlFp6OIwnn6EYAPWAh1A4g199zhZXrOj/KB6Zo3Daoy+En/Qci/963A==","mode":420,"size":859},"dist/index.d.ts":{"checkedAt":1794532098055,"integrity":"sha512-Dn8Hj8fC9d/twwzQ+Zvz7xymliVuPKXoQ5k5OBZMitFJHA1PvP6GjFM0zbnaeNY125qDdpjkyz2Lg1f+oVio0g==","mode":420,"size":396},"dist/parser.d.ts":{"checkedAt":1794532098055,"integrity":"sha512-l2GlPKcug4KqYFubsY0p+YWv4EnqpQdHNwhSc9lWOYwp8MeHJUz9MppJK4eWlDmf44tKotKJ+uAyEuXa8xj8VQ==","mode":420,"size":965}}}

.pnpm-store/v3/files/b4/b02fc0e20bae251253e932378d3480a2c0eeffac39ad2db8d36bf28023eaeedcc58da43a6a90af2f6feac585663b68d523b9c136e524eda367e41fec63ee67

@@ -0,0 +1,13 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { IconSvgProps } from './types.mjs';
+import 'react';
+
+declare const CloseIcon: (props: IconSvgProps & {
+    "data-checked"?: string;
+    isSelected?: boolean;
+    isIndeterminate?: boolean;
+    disableAnimation?: boolean;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+export { CloseIcon };

.pnpm-store/v3/files/b4/b0478b1a22bfb251169e3164b6235b6808e6fd8f985d4f47d350926b52bca1706311ddce48ecb403616ff90280099dd9d5142a46ac3014048eb65361e4a1c2

@@ -0,0 +1,6 @@
+function isValid(date) {
+  return date.toString() !== "Invalid Date";
+}
+export {
+  isValid as default
+};

.pnpm-store/v3/files/b4/b0497740cfa78e85927cd178596558adf563cf34e577b3b8dc0adbd5562813ca2222bd0a065a4e20bc835a0efe7d6254ee40f821d7924448c6a8c280cc09ce

@@ -0,0 +1,12 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type UnionStatic<T extends TSchema[], P extends unknown[]> = {
+    [K in keyof T]: T[K] extends TSchema ? Static<T[K], P> : never;
+}[number];
+export interface TUnion<T extends TSchema[] = TSchema[]> extends TSchema {
+    [Kind]: 'Union';
+    static: UnionStatic<T, this['params']>;
+    anyOf: T;
+}
+export {};

.pnpm-store/v3/files/b4/b204723e46b91d914939f134a7642b4749fc6ac2ecfdfcb149220e60ee1dfb0799b6a04c50310d520196da24957115210fdfd7820bf08309e699fd1decf513-index.json

@@ -0,0 +1 @@
+{"name":"aproba","version":"2.1.0","requiresBuild":false,"files":{"LICENSE":{"checkedAt":1794532123125,"integrity":"sha512-XkuoBvJ5CJ1wXpCePAAGdMQYbWGNarOBYZCZ+Ila8Cl58/yau0P3i5/+0zuQp4YfbEudbBu0ftFKeef5DsqDPA==","mode":420,"size":752},"index.js":{"checkedAt":1794532123126,"integrity":"sha512-sWVXTdO50+uptO5u6lvHzmbgJqZOfhJwQbsEY+YA8B8O8niTS9PBgcBcNj2+S7NWLfR9wsn5gsEHvsUOcSezfA==","mode":420,"size":3648},"package.json":{"checkedAt":1794532123126,"integrity":"sha512-Nztedt/jZIR0d6NyYBh3USwgvUsQ71MYpf9+dF3Pdy5b1W9QVzrfYIz2ubfk6HzBUzWTmCyu0XV+rS1r3gnorQ==","mode":420,"size":740},"README.md":{"checkedAt":1794532123126,"integrity":"sha512-OUVMD7HzcVexfApctsfx9r6XlnnXyqvAhlVueLuHKcWX8/yXV7KQCs8DlGNj+xf3GKcHXvRJDA/MtI8VJU7s8w==","mode":420,"size":2743}}}

.pnpm-store/v3/files/b4/b30c9983872b8c20f472001f65c5b9b60fbcb2e9f27fcfe042a6c7e9c6f0bd35522c6f5615286de96d9edd4e9b95ff2ccffc64841a56b378d8aaa75555f181

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you 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
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {createEventHandler} from './createEventHandler';
+import {DOMAttributes, KeyboardEvents} from '@react-types/shared';
+
+export interface KeyboardProps extends KeyboardEvents {
+  /** Whether the keyboard events should be disabled. */
+  isDisabled?: boolean
+}
+
+export interface KeyboardResult {
+  /** Props to spread onto the target element. */
+  keyboardProps: DOMAttributes
+}
+
+/**
+ * Handles keyboard interactions for a focusable element.
+ */
+export function useKeyboard(props: KeyboardProps): KeyboardResult {
+  return {
+    keyboardProps: props.isDisabled ? {} : {
+      onKeyDown: createEventHandler(props.onKeyDown),
+      onKeyUp: createEventHandler(props.onKeyUp)
+    }
+  };
+}

.pnpm-store/v3/files/b4/b5003fb3d01a8727a5884a846985b3bc25fa4f50caf9a151e9dcf164eb7ac9e8770bbe4cd0e87464b49f1fc7ab01f0add9f5e09c2875063c387e5022ece1d4

@@ -0,0 +1,45 @@
+import baseFill from './_baseFill.js';
+import isIterateeCall from './_isIterateeCall.js';
+
+/**
+ * Fills elements of `array` with `value` from `start` up to, but not
+ * including, `end`.
+ *
+ * **Note:** This method mutates `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.2.0
+ * @category Array
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ * @example
+ *
+ * var array = [1, 2, 3];
+ *
+ * _.fill(array, 'a');
+ * console.log(array);
+ * // => ['a', 'a', 'a']
+ *
+ * _.fill(Array(3), 2);
+ * // => [2, 2, 2]
+ *
+ * _.fill([4, 6, 8, 10], '*', 1, 3);
+ * // => [4, '*', '*', 10]
+ */
+function fill(array, value, start, end) {
+  var length = array == null ? 0 : array.length;
+  if (!length) {
+    return [];
+  }
+  if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
+    start = 0;
+    end = length;
+  }
+  return baseFill(array, value, start, end);
+}
+
+export default fill;