TanTan/SnowLuma
1
0 Fork 0
Code Issues Pull Requests Actions 8 Packages Projects Releases 1 Wiki Activity

docs: 仓库链接指向本镜像仓库
Dev Build / cleanup (push) Waiting to run
Details
Dev Build / typecheck (push) Waiting to run
Details

Browse Source
This commit is contained in:
TanTan committed 2026-11-13 09:27:07 +08:00
1 parent fa9c73363d
commit 2a69b23b47
18210 files changed
+5101211 -16
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.pnpm-store/v11/files/58/01eb2324d399663b59b0aff2b77b4c3641ec910aab59ccef79e9844a33acb28cd4a90b3c2d2da8e7a2b403b77c1967936fa2072d6119de832e6dd42abd57e6
+17
View File
@@ -0,0 +1,17 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const BetweenVerticalEnd = createLucideIcon("BetweenVerticalEnd", [
["rect", { width: "7", height: "13", x: "3", y: "3", rx: "1", key: "1fdu0f" }],
["path", { d: "m9 22 3-3 3 3", key: "17z65a" }],
["rect", { width: "7", height: "13", x: "14", y: "3", rx: "1", key: "1squn4" }]
]);
export { BetweenVerticalEnd as default };
//# sourceMappingURL=between-vertical-end.js.map
.pnpm-store/v11/files/58/079b662666f1a16f965c17836a3c5725ab3295a2854c94e41173a0a69fbbeddf2334352e32dcba6feb4b15985899f701d43cb691493bc947655aa13da4377c
+1748
View File
File diff suppressed because it is too large. Load diff
.pnpm-store/v11/files/58/0bc940cb3dfb0ecba48a73a4e30376b17de5c961802c8030062e4c86f170af21f505d232b9cdd80ffdf1cf891ccfd6b13ce79de269439e47a276b1745dc695
+56
View File
@@ -0,0 +1,56 @@
{
"name": "@tanstack/virtual-core",
"version": "3.17.3",
"description": "Headless UI for virtualizing scrollable elements in TS/JS + Frameworks",
"author": "Tanner Linsley",
"license": "MIT",
"repository": {
"type": "git",
"url": "git+https://github.com/TanStack/virtual.git",
"directory": "packages/virtual-core"
},
"homepage": "https://tanstack.com/virtual",
"funding": {
"type": "github",
"url": "https://github.com/sponsors/tannerlinsley"
},
"keywords": [
"react",
"vue",
"solid",
"virtual",
"virtual-core",
"datagrid"
],
"type": "module",
"types": "dist/esm/index.d.ts",
"main": "dist/cjs/index.cjs",
"module": "dist/esm/index.js",
"exports": {
".": {
"import": {
"types": "./dist/esm/index.d.ts",
"default": "./dist/esm/index.js"
},
"require": {
"types": "./dist/cjs/index.d.cts",
"default": "./dist/cjs/index.cjs"
}
},
"./package.json": "./package.json"
},
"sideEffects": false,
"files": [
"dist",
"src"
],
"scripts": {
"clean": "premove ./dist ./coverage",
"test:eslint": "eslint ./src",
"test:types": "tsc",
"test:lib": "vitest",
"test:lib:dev": "pnpm run test:lib --watch",
"test:build": "publint --strict",
"build": "vite build"
}
}
.pnpm-store/v11/files/58/0ccfc2b2a90484edc8e0dd90ffc326a18f13ee92883eba27a5e1985cb32969af7e312123f7cd1c5fd973a15d2748deedccf4f9b4e08759594bf8cf7de0553c
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"paw-print.js","sources":["../../../src/icons/paw-print.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name PawPrint\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8Y2lyY2xlIGN4PSIxMSIgY3k9IjQiIHI9IjIiIC8+CiAgPGNpcmNsZSBjeD0iMTgiIGN5PSI4IiByPSIyIiAvPgogIDxjaXJjbGUgY3g9IjIwIiBjeT0iMTYiIHI9IjIiIC8+CiAgPHBhdGggZD0iTTkgMTBhNSA1IDAgMCAxIDUgNXYzLjVhMy41IDMuNSAwIDAgMS02Ljg0IDEuMDQ1UTYuNTIgMTcuNDggNC40NiAxNi44NEEzLjUgMy41IDAgMCAxIDUuNSAxMFoiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/paw-print\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst PawPrint = createLucideIcon('PawPrint', [\n ['circle', { cx: '11', cy: '4', r: '2', key: 'vol9p0' }],\n ['circle', { cx: '18', cy: '8', r: '2', key: '17gozi' }],\n ['circle', { cx: '20', cy: '16', r: '2', key: '1v9bxh' }],\n [\n 'path',\n {\n d: 'M9 10a5 5 0 0 1 5 5v3.5a3.5 3.5 0 0 1-6.84 1.045Q6.52 17.48 4.46 16.84A3.5 3.5 0 0 1 5.5 10Z',\n key: '1ydw1z',\n },\n ],\n]);\n\nexport default PawPrint;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAW,iBAAiB,UAAY,CAAA,CAAA,CAAA;AAAA,CAC5C,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAM,CAAI,CAAA,CAAA,CAAA,GAAA,CAAK,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA,CAAA;AAAA,CACvD,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAM,CAAI,CAAA,CAAA,CAAA,GAAA,CAAK,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA,CAAA;AAAA,CACvD,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAM,CAAI,CAAA,CAAA,CAAA,IAAA,CAAM,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA,CAAA;AAAA,CACxD,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA;AACF,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/13c77fe083faf40b4b0ccb08cc40ca45e00b94245c9ec9e62ee24c9385ae6a0486d6d4fc3709dd93f91ad03e391e94327d38a4f86b6eb02e6de25bdf1b2665
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"shield-alert.js","sources":["../../../src/icons/shield-alert.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name ShieldAlert\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMjAgMTNjMCA1LTMuNSA3LjUtNy42NiA4Ljk1YTEgMSAwIDAgMS0uNjctLjAxQzcuNSAyMC41IDQgMTggNCAxM1Y2YTEgMSAwIDAgMSAxLTFjMiAwIDQuNS0xLjIgNi4yNC0yLjcyYTEuMTcgMS4xNyAwIDAgMSAxLjUyIDBDMTQuNTEgMy44MSAxNyA1IDE5IDVhMSAxIDAgMCAxIDEgMXoiIC8+CiAgPHBhdGggZD0iTTEyIDh2NCIgLz4KICA8cGF0aCBkPSJNMTIgMTZoLjAxIiAvPgo8L3N2Zz4K) - https://lucide.dev/icons/shield-alert\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst ShieldAlert = createLucideIcon('ShieldAlert', [\n [\n 'path',\n {\n d: 'M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z',\n key: 'oel41y',\n },\n ],\n ['path', { d: 'M12 8v4', key: '1got3b' }],\n ['path', { d: 'M12 16h.01', key: '1drbdi' }],\n]);\n\nexport default ShieldAlert;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAc,iBAAiB,aAAe,CAAA,CAAA,CAAA;AAAA,CAClD,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CAAA,CACA,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACxC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAc,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC7C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/1560f74f623e4076c6a233b8a2dde7522b3479815c18aae384e06da00cd1a640207a9cf8e85ef58d96d5d4204c26681a121bf09a2b3e706ab820e6cf540256-exec
Executable
+12
View File
@@ -0,0 +1,12 @@
#!/usr/bin/env node
"use strict";
var _chunkDI5BO6XEjs = require('./chunk-DI5BO6XE.js');
require('./chunk-PEEXUWMS.js');
var _chunkJZ25TPTYjs = require('./chunk-JZ25TPTY.js');
require('./chunk-TWFEYLU4.js');
// src/cli-default.ts
_chunkDI5BO6XEjs.main.call(void 0, ).catch(_chunkJZ25TPTYjs.handleError);
.pnpm-store/v11/files/58/18328b466b09a6087aa169c104cc655b0d239f11c17906281c1e35707e0fe1b4fe2100fed419bc1aafca2ab6573bad9901b08a6a853050564f945ad42e3744
+116
View File
@@ -0,0 +1,116 @@
import * as util from "../core/util.js";
const error = () => {
const Sizable = {
string: { unit: "ಅಕ್ಷರಗಳು", verb: "ಹೊಂದಲು" },
file: { unit: "ಬೈಟ್‌ಗಳು", verb: "ಹೊಂದಲು" },
array: { unit: "ವಸ್ತುಗಳು", verb: "ಹೊಂದಲು" },
set: { unit: "ವಸ್ತುಗಳು", verb: "ಹೊಂದಲು" },
map: { unit: "entries", verb: "ಹೊಂದಲು" },
};
function getSizing(origin) {
return Sizable[origin] ?? null;
}
const FormatDictionary = {
regex: "ಇನ್ಪುಟ್",
email: "email ವಿಳಾಸ",
url: "URL",
emoji: "emoji",
uuid: "UUID",
uuidv4: "UUIDv4",
uuidv6: "UUIDv6",
nanoid: "nanoid",
guid: "GUID",
cuid: "cuid",
cuid2: "cuid2",
ulid: "ULID",
xid: "XID",
ksuid: "KSUID",
datetime: "ISO ದಿನಾಂಕದ ಸಮಯ",
date: "ISO ದಿನಾಂಕ",
time: "ISO ಸಮಯ",
duration: "ISO ಅವಧಿ",
ipv4: "IPv4 ವಿಳಾಸ",
ipv6: "IPv6 ವಿಳಾಸ",
mac: "MAC ವಿಳಾಸ",
cidrv4: "IPv4 ವ್ಯಾಪ್ತಿಯ",
cidrv6: "IPv6 ವ್ಯಾಪ್ತಿಯ",
base64: "base64-encodedಸ್ಟ್ರಿಂಗ್",
base64url: "base64url-encodedಸ್ಟ್ರಿಂಗ್",
json_string: "JSONಸ್ಟ್ರಿಂಗ್",
e164: "E.164 ಸಂಖ್ಯೆ",
credit_card: "ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆ",
currency_code: "ಕರೆನ್ಸಿ ಕೋಡ್",
iban: "IBAN",
jwt: "JWT",
template_literal: "ಇನ್ಪುಟ್",
};
// type names: missing keys = do not translate (use raw value via ?? fallback)
const TypeDictionary = {
// Compatibility: "nan" -> "NaN" for display
nan: "NaN",
// All other type names omitted - they fall back to raw values via ?? operator
};
return (issue) => {
switch (issue.code) {
case "invalid_type": {
const expected = TypeDictionary[issue.expected] ?? issue.expected;
const receivedType = util.parsedType(issue.input);
const received = TypeDictionary[receivedType] ?? receivedType;
return `ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${expected}, ಸ್ವೀಕರಿಸಿದನು ${received}`;
}
case "invalid_value":
if (issue.values.length === 1)
return `ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${util.stringifyPrimitive(issue.values[0])}`;
return `ಅಮಾನ್ಯ ಆಯ್ಕೆ: ಇವುಗಳಲ್ಲಿ ಒಂದನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${util.joinValues(issue.values, "|")}`;
case "too_big": {
const adj = issue.inclusive ? "<=" : "<";
const sizing = getSizing(issue.origin);
if (sizing)
return `ತುಂಬಾ ದೊಡ್ಡದು: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${issue.origin ?? "value"} ಹೊಂದಲು ${adj}${issue.maximum.toString()} ${sizing.unit ?? "ಅಂಶಗಳು"}`;
return `ತುಂಬಾ ದೊಡ್ಡದು: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${issue.origin ?? "value"} ಎಂದು ${adj}${issue.maximum.toString()}`;
}
case "too_small": {
const adj = issue.inclusive ? ">=" : ">";
const sizing = getSizing(issue.origin);
if (sizing) {
return `ತುಂಬಾ ಚಿಕ್ಕದು: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${issue.origin} ಹೊಂದಲು ${adj}${issue.minimum.toString()} ${sizing.unit}`;
}
return `ತುಂಬಾ ಚಿಕ್ಕದು: ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${issue.origin} ಎಂದು ${adj}${issue.minimum.toString()}`;
}
case "invalid_format": {
const _issue = issue;
if (_issue.format === "starts_with") {
return `ಅಮಾನ್ಯವಾದ ಸ್ಟ್ರಿಂಗ್: ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು "${_issue.prefix}"`;
}
if (_issue.format === "ends_with")
return `ಅಮಾನ್ಯವಾದ ಸ್ಟ್ರಿಂಗ್: ಇದರೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಬೇಕು "${_issue.suffix}"`;
if (_issue.format === "includes")
return `ಅಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್: ಒಳಗೊಂಡಿರಬೇಕು "${_issue.includes}"`;
if (_issue.format === "regex")
return `ಅಮಾನ್ಯವಾದ ಸ್ಟ್ರಿಂಗ್: ಮಾದರಿಗೆ ಹೊಂದಿಕೆಯಾಗಬೇಕು ${_issue.pattern}`;
return `ಅಮಾನ್ಯ ${FormatDictionary[_issue.format] ?? issue.format}`;
}
case "not_multiple_of":
return `ಅಮಾನ್ಯ ಸಂಖ್ಯೆ: ಬಹುಸಂಖ್ಯೆಯಾಗಿರಬೇಕು ${issue.divisor}`;
case "unrecognized_keys":
return `ಗುರುತಿಸಲಾಗದ ಕೀ ${issue.keys.length > 1 ? "s" : ""}: ${util.joinValues(issue.keys, ", ")}`;
case "invalid_key":
return `ಅಮಾನ್ಯವಾದ ಕೀ ಇನ್ ${issue.origin}`;
case "invalid_union":
if (issue.options && Array.isArray(issue.options) && issue.options.length > 0) {
const opts = issue.options.map((o) => `'${o}'`).join(" | ");
return `ಅಮಾನ್ಯ ತಾರತಮ್ಯ ಮೌಲ್ಯ. ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ${opts}`;
}
return "ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್";
case "invalid_element":
return `ರಲ್ಲಿ ಅಮಾನ್ಯ ಮೌಲ್ಯ ${issue.origin}`;
default:
return `ಅಮಾನ್ಯ ಇನ್‌ಪುಟ್`;
}
};
};
export default function () {
return {
localeError: error(),
};
}
.pnpm-store/v11/files/58/19be197323e55ee25b51373380772a72a1736db539d5f2148f817975efd5227d23b88af3828852664a91a9907ab6abaa95775b820f3984a2f306afe7a0bf50
+7
View File
@@ -0,0 +1,7 @@
'use strict';
if (process.env.NODE_ENV === 'production') {
module.exports = require('./cjs/scheduler-unstable_post_task.production.js');
} else {
module.exports = require('./cjs/scheduler-unstable_post_task.development.js');
}
.pnpm-store/v11/files/58/1b2ac3ad592c72095ded285de1da79c59db6e0a2c5f63f57be639e0765b895beffb1f32d0842128640a2f8d0fa0b89f8d91952fb5985c32c6e437db2e380e2
+95
View File
@@ -0,0 +1,95 @@
{
"name": "qs",
"description": "A querystring parser that supports nesting and arrays, with a depth limit",
"homepage": "https://github.com/ljharb/qs",
"version": "6.16.1",
"repository": {
"type": "git",
"url": "https://github.com/ljharb/qs.git"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
},
"main": "lib/index.js",
"sideEffects": false,
"contributors": [
{
"name": "Jordan Harband",
"email": "ljharb@gmail.com",
"url": "http://ljharb.codes"
}
],
"keywords": [
"querystring",
"qs",
"query",
"url",
"parse",
"stringify"
],
"engines": {
"node": ">=0.6"
},
"dependencies": {
"es-define-property": "^1.0.1",
"side-channel": "^1.1.1"
},
"devDependencies": {
"@browserify/envify": "^6.0.0",
"@browserify/uglifyify": "^6.0.0",
"@ljharb/eslint-config": "^22.2.5",
"browserify": "^16.5.2",
"bundle-collapser": "^1.4.0",
"common-shakeify": "~1.0.0",
"eclint": "^2.8.1",
"es-value-fixtures": "^1.7.1",
"eslint": "^10.12.0",
"evalmd": "^0.0.22",
"for-each": "^0.3.5",
"glob": "=10.3.7",
"has-bigints": "^1.1.0",
"has-override-mistake": "^1.0.1",
"has-property-descriptors": "^1.0.2",
"has-proto": "^1.2.0",
"has-symbols": "^1.1.0",
"iconv-lite": "^0.5.2",
"in-publish": "^2.0.1",
"jackspeak": "=2.1.1",
"jiti": "^0.0.0",
"mkdirp": "^0.5.5",
"mock-property": "^1.1.2",
"module-deps": "^6.2.3",
"npmignore": "^0.3.5",
"nyc": "^10.3.2",
"object-inspect": "^1.13.4",
"qs-iconv": "^1.0.4",
"safe-publish-latest": "^2.0.0",
"safer-buffer": "^2.1.2",
"tape": "^5.10.3",
"unassertify": "^3.0.1"
},
"scripts": {
"prepack": "npmignore --auto --commentLines=autogenerated && npm run dist",
"prepublishOnly": "safe-publish-latest",
"prepublish": "not-in-publish || npm run prepublishOnly",
"pretest": "npm run --silent readme && npm run --silent lint",
"test": "npm run tests-only",
"tests-only": "nyc tape 'test/**/*.js'",
"posttest": "npx npm@'>=10.2' audit --production",
"readme": "evalmd README.md",
"postlint": "eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git' | grep -v dist/)",
"lint": "eslint .",
"dist": "mkdirp dist && browserify --standalone Qs -g unassertify -g @browserify/envify -g [@browserify/uglifyify --mangle.keep_fnames --compress.keep_fnames --format.indent_level=1 --compress.arrows=false --compress.passes=4 --compress.typeofs=false] -p common-shakeify -p bundle-collapser/plugin lib/index.js > dist/qs.js"
},
"license": "BSD-3-Clause",
"publishConfig": {
"ignore": [
"!dist/*",
"bower.json",
"component.json",
".github/workflows",
"logos",
"tea.yaml"
]
}
}
.pnpm-store/v11/files/58/1bffcd8b6cb129b9dff597f3a92fa70f5982f823bd867df62e93b0bdeda27ecee2cb42cc5b7ca03c0979567f5cfed8df8e42227c7b818588e809c2034442b2
+16
View File
@@ -0,0 +1,16 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const Redo2 = createLucideIcon("Redo2", [
["path", { d: "m15 14 5-5-5-5", key: "12vg1m" }],
["path", { d: "M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13", key: "6uklza" }]
]);
export { Redo2 as default };
//# sourceMappingURL=redo-2.js.map
.pnpm-store/v11/files/58/2394df204200e79107adc8af667989059253ea5dde38e82be217e9cecea289e83253d9c87f082708092b9e0cb0cc8c8a9724bc45b040068907adcc025b4aa0
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"helpers.d.ts","sourceRoot":"https://raw.githubusercontent.com/fb55/domutils/0ab8bcf1ecfc70dfc93291a4cb2496578ac25e9c/src/","sources":["helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,OAAO,EAAc,MAAM,YAAY,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CA6BzD;AACD;;;GAGG;AACH,0BAAkB,gBAAgB;IAC9B,YAAY,IAAI;IAChB,SAAS,IAAI;IACb,SAAS,IAAI;IACb,QAAQ,IAAI;IACZ,YAAY,KAAK;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,uBAAuB,CACnC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,GACf,MAAM,CA4CR;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAc7D"}
.pnpm-store/v11/files/58/24d145c30dd5ae011e39ea8da0e75787174a915f96486f07ccdb8578f75e2418a30971ffe2be5149442e0056e89a841a158adc0f858cf80566f09d1d7cd143
+41
View File
@@ -0,0 +1,41 @@
'use strict';
var utils = require('../../../../scoring/utils.cjs');
var _const = require('../../../../data/const.cjs');
const getVariations = cleanedWord => {
const wordArray = cleanedWord.split('');
const upperCaseCount = wordArray.filter(char => char.match(_const.ONE_UPPER)).length;
const lowerCaseCount = wordArray.filter(char => char.match(_const.ONE_LOWER)).length;
let variations = 0;
const variationLength = Math.min(upperCaseCount, lowerCaseCount);
for (let i = 1; i <= variationLength; i += 1) {
variations += utils.nCk(upperCaseCount + lowerCaseCount, i);
}
return variations;
};
var uppercaseVariant = word => {
// clean words of non alpha characters to remove the reward effekt to capitalize the first letter https://github.com/dropbox/zxcvbn/issues/232
const cleanedWord = word.replace(_const.ALPHA_INVERTED, '');
if (cleanedWord.match(_const.ALL_LOWER_INVERTED) || cleanedWord.toLowerCase() === cleanedWord) {
return 1;
}
// a capitalized word is the most common capitalization scheme,
// so it only doubles the search space (uncapitalized + capitalized).
// all caps and end-capitalized are common enough too, underestimate as 2x factor to be safe.
const commonCases = [_const.START_UPPER, _const.END_UPPER, _const.ALL_UPPER_INVERTED];
const commonCasesLength = commonCases.length;
for (let i = 0; i < commonCasesLength; i += 1) {
const regex = commonCases[i];
if (cleanedWord.match(regex)) {
return 2;
}
}
// otherwise calculate the number of ways to capitalize U+L uppercase+lowercase letters
// with U uppercase letters or less. or, if there's more uppercase than lower (for eg. PASSwORD),
// the number of ways to lowercase U+L letters with L lowercase letters or less.
return getVariations(cleanedWord);
};
module.exports = uppercaseVariant;
//# sourceMappingURL=uppercase.cjs.map
.pnpm-store/v11/files/58/28a061d59b6273805621bc067975afa8aa048cb970be7fcee25eb473be37d5c8fe558a89ac55dee00787f62fb0ee8fee5f4082447adc00c562de8558fe3e5e
+930
View File
@@ -0,0 +1,930 @@
import { MockInstance } from '@vitest/spy';
import { Formatter } from 'tinyrainbow';
import { StandardSchemaV1 } from '@standard-schema/spec';
import { diff, printDiffOrStringify } from '@vitest/utils/diff';
export { DiffOptions } from '@vitest/utils/diff';
import { stringify } from '@vitest/utils/display';
import * as chai from 'chai';
export { chai };
interface AsymmetricMatcherInterface {
asymmetricMatch: (other: unknown, customTesters?: Array<Tester>) => boolean;
toString: () => string;
getExpectedType?: () => string;
toAsymmetricMatcher?: () => string;
}
declare abstract class AsymmetricMatcher<
T,
State extends MatcherState = MatcherState
> implements AsymmetricMatcherInterface {
protected sample: T;
protected inverse: boolean;
$$typeof: symbol;
constructor(sample: T, inverse?: boolean);
protected getMatcherContext(expect?: Chai.ExpectStatic): State;
abstract asymmetricMatch(other: unknown, customTesters?: Array<Tester>): boolean;
abstract toString(): string;
getExpectedType?(): string;
toAsymmetricMatcher?(): string;
}
declare class StringContaining extends AsymmetricMatcher<string> {
constructor(sample: string, inverse?: boolean);
asymmetricMatch(other: string): boolean;
toString(): string;
getExpectedType(): string;
}
declare class Anything extends AsymmetricMatcher<void> {
asymmetricMatch(other: unknown): boolean;
toString(): string;
toAsymmetricMatcher(): string;
}
declare class ObjectContaining extends AsymmetricMatcher<Record<string | symbol | number, unknown>> {
constructor(sample: Record<string, unknown>, inverse?: boolean);
getPrototype(obj: object): any;
hasProperty(obj: object | null, property: string | symbol): boolean;
getProperties(obj: object): (string | symbol)[];
asymmetricMatch(other: any, customTesters?: Array<Tester>): boolean;
toString(): string;
getExpectedType(): string;
}
declare class ArrayContaining<T = unknown> extends AsymmetricMatcher<Array<T>> {
constructor(sample: Array<T>, inverse?: boolean);
asymmetricMatch(other: Array<T>, customTesters?: Array<Tester>): boolean;
toString(): string;
getExpectedType(): string;
}
declare class Any extends AsymmetricMatcher<any> {
constructor(sample: unknown);
fnNameFor(func: Function): string;
asymmetricMatch(other: unknown): boolean;
toString(): string;
getExpectedType(): string;
toAsymmetricMatcher(): string;
}
declare class StringMatching extends AsymmetricMatcher<RegExp> {
constructor(sample: string | RegExp, inverse?: boolean);
asymmetricMatch(other: string): boolean;
toString(): string;
getExpectedType(): string;
}
declare class SchemaMatching extends AsymmetricMatcher<StandardSchemaV1<unknown, unknown>> {
private result;
constructor(sample: StandardSchemaV1<unknown, unknown>, inverse?: boolean);
asymmetricMatch(other: unknown): boolean;
toString(): string;
getExpectedType(): string;
toAsymmetricMatcher(): string;
}
declare const JestAsymmetricMatchers: ChaiPlugin;
declare function matcherHint(matcherName: string, received?: string, expected?: string, options?: MatcherHintOptions): string;
declare function printReceived(object: unknown): string;
declare function printExpected(value: unknown): string;
declare function getMatcherUtils(): {
EXPECTED_COLOR: Formatter;
RECEIVED_COLOR: Formatter;
INVERTED_COLOR: Formatter;
BOLD_WEIGHT: Formatter;
DIM_COLOR: Formatter;
diff: typeof diff;
matcherHint: typeof matcherHint;
printReceived: typeof printReceived;
printExpected: typeof printExpected;
printDiffOrStringify: typeof printDiffOrStringify;
printWithType: typeof printWithType;
};
declare function printWithType<T>(name: string, value: T, print: (value: T) => string): string;
declare function addCustomEqualityTesters(newTesters: Array<Tester>): void;
/**
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
*/
type ChaiPlugin = Chai.ChaiPlugin;
type Tester = (this: TesterContext, a: any, b: any, customTesters: Array<Tester>) => boolean | undefined;
interface TesterContext {
equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
}
interface MatcherHintOptions {
comment?: string;
expectedColor?: Formatter;
isDirectExpectCall?: boolean;
isNot?: boolean;
promise?: string;
receivedColor?: Formatter;
secondArgument?: string;
secondArgumentColor?: Formatter;
}
interface MatcherState {
customTesters: Array<Tester>;
assertionCalls: number;
currentTestName?: string;
/**
* @deprecated exists only in types
*/
dontThrow?: () => void;
/**
* @deprecated exists only in types
*/
error?: Error;
equals: (a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean) => boolean;
/**
* @deprecated exists only in types
*/
expand?: boolean;
expectedAssertionsNumber?: number | null;
expectedAssertionsNumberErrorGen?: (() => Error) | null;
isExpectingAssertions?: boolean;
isExpectingAssertionsError?: Error | null;
isNot: boolean;
promise: string;
/**
* @deprecated exists only in types
*/
suppressedErrors: Array<Error>;
testPath?: string;
utils: ReturnType<typeof getMatcherUtils> & {
diff: typeof diff;
stringify: typeof stringify;
iterableEquality: Tester;
subsetEquality: Tester;
};
soft?: boolean;
poll?: boolean;
/**
* The same assertion instance that chai plugins receive.
* @experimental
* @see {@link https://www.chaijs.com/guide/plugins/} Core Plugin Concepts
*/
readonly assertion: Assertion;
}
interface SyncExpectationResult {
pass: boolean;
message: () => string;
actual?: any;
expected?: any;
meta?: object;
}
type AsyncExpectationResult = Promise<SyncExpectationResult>;
type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
interface RawMatcherFn<
T extends MatcherState = MatcherState,
E extends Array<any> = Array<any>
> {
(this: T, received: any, ...expected: E): ExpectationResult;
}
interface Matchers<T = any> {}
type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>> & ThisType<T> & { [K in keyof Matchers<T>]? : RawMatcherFn<T, Parameters<Matchers<T>[K]>> };
interface ExpectStatic extends Chai.ExpectStatic, Matchers, AsymmetricMatchersContaining {
<T>(actual: T, message?: string): Assertion<T>;
extend: (expects: MatchersObject) => void;
anything: () => any;
any: (constructor: unknown) => any;
getState: () => MatcherState;
setState: (state: Partial<MatcherState>) => void;
not: AsymmetricMatchersContaining;
}
interface CustomMatcher {
/**
* Checks that a value satisfies a custom matcher function.
*
* @param matcher - A function returning a boolean based on the custom condition
* @param message - Optional custom error message on failure
*
* @example
* expect(age).toSatisfy(val => val >= 18, 'Age must be at least 18');
* expect(age).toEqual(expect.toSatisfy(val => val >= 18, 'Age must be at least 18'));
*/
toSatisfy: (matcher: (value: any) => boolean, message?: string) => any;
/**
* Matches if the received value is one of the values in the expected array or set.
*
* @example
* expect(1).toBeOneOf([1, 2, 3])
* expect('foo').toBeOneOf([expect.any(String)])
* expect({ a: 1 }).toEqual({ a: expect.toBeOneOf(['1', '2', '3']) })
*/
toBeOneOf: <T>(sample: Array<T> | Set<T>) => any;
}
interface AsymmetricMatchersContaining extends CustomMatcher {
/**
* Matches if the received string contains the expected substring.
*
* @example
* expect('I have an apple').toEqual(expect.stringContaining('apple'));
* expect({ a: 'test string' }).toEqual({ a: expect.stringContaining('test') });
*/
stringContaining: (expected: string) => any;
/**
* Matches if the received object contains all properties of the expected object.
*
* @example
* expect({ a: '1', b: 2 }).toEqual(expect.objectContaining({ a: '1' }))
*/
objectContaining: <T = any>(expected: DeeplyAllowMatchers<T>) => any;
/**
* Matches if the received array contains all elements in the expected array.
*
* @example
* expect(['a', 'b', 'c']).toEqual(expect.arrayContaining(['b', 'a']));
*/
arrayContaining: <T = unknown>(expected: Array<DeeplyAllowMatchers<T>>) => any;
/**
* Matches if the received string or regex matches the expected pattern.
*
* @example
* expect('hello world').toEqual(expect.stringMatching(/^hello/));
* expect('hello world').toEqual(expect.stringMatching('hello'));
*/
stringMatching: (expected: string | RegExp) => any;
/**
* Matches if the received number is within a certain precision of the expected number.
*
* @example
* expect(10.45).toEqual(expect.closeTo(10.5, 1));
* expect(5.11).toEqual(expect.closeTo(5.12)); // with default precision
*/
closeTo: (expected: number, precision?: number) => any;
/**
* Matches if the received value validates against a Standard Schema.
*
* @param schema - A Standard Schema V1 compatible schema object
*
* @example
* expect(user).toEqual(expect.schemaMatching(z.object({ name: z.string() })))
* expect(['hello', 'world']).toEqual([expect.schemaMatching(z.string()), expect.schemaMatching(z.string())])
*/
schemaMatching: (schema: unknown) => any;
}
type WithAsymmetricMatcher<T> = T | AsymmetricMatcher<unknown>;
type DeeplyAllowMatchers<T> = T extends Array<infer Element> ? WithAsymmetricMatcher<T> | DeeplyAllowMatchers<Element>[] : T extends object ? WithAsymmetricMatcher<T> | { [K in keyof T] : DeeplyAllowMatchers<T[K]> } : WithAsymmetricMatcher<T>;
interface JestAssertion<T = any> extends jest.Matchers<void, T>, CustomMatcher {
/**
* Used when you want to check that two objects have the same value.
* This matcher recursively checks the equality of all fields, rather than checking for object identity.
*
* @example
* expect(user).toEqual({ name: 'Alice', age: 30 });
*/
toEqual: <E>(expected: E) => void;
/**
* Use to test that objects have the same types as well as structure.
*
* @example
* expect(user).toStrictEqual({ name: 'Alice', age: 30 });
*/
toStrictEqual: <E>(expected: E) => void;
/**
* Checks that a value is what you expect. It calls `Object.is` to compare values.
* Don't use `toBe` with floating-point numbers.
*
* @example
* expect(result).toBe(42);
* expect(status).toBe(true);
*/
toBe: <E>(expected: E) => void;
/**
* Check that a string matches a regular expression.
*
* @example
* expect(message).toMatch(/hello/);
* expect(greeting).toMatch('world');
*/
toMatch: (expected: string | RegExp) => void;
/**
* Used to check that a JavaScript object matches a subset of the properties of an object
*
* @example
* expect(user).toMatchObject({
* name: 'Alice',
* address: { city: 'Wonderland' }
* });
*/
toMatchObject: <E extends object | any[]>(expected: E) => void;
/**
* Used when you want to check that an item is in a list.
* For testing the items in the list, this uses `===`, a strict equality check.
*
* @example
* expect(items).toContain('apple');
* expect(numbers).toContain(5);
*/
toContain: <E>(item: E) => void;
/**
* Used when you want to check that an item is in a list.
* For testing the items in the list, this matcher recursively checks the
* equality of all fields, rather than checking for object identity.
*
* @example
* expect(items).toContainEqual({ name: 'apple', quantity: 1 });
*/
toContainEqual: <E>(item: E) => void;
/**
* Use when you don't care what a value is, you just want to ensure a value
* is true in a boolean context. In JavaScript, there are six falsy values:
* `false`, `0`, `''`, `null`, `undefined`, and `NaN`. Everything else is truthy.
*
* @example
* expect(user.isActive).toBeTruthy();
*/
toBeTruthy: () => void;
/**
* When you don't care what a value is, you just want to
* ensure a value is false in a boolean context.
*
* @example
* expect(user.isActive).toBeFalsy();
*/
toBeFalsy: () => void;
/**
* For comparing floating point numbers.
*
* @example
* expect(score).toBeGreaterThan(10);
*/
toBeGreaterThan: (num: number | bigint) => void;
/**
* For comparing floating point numbers.
*
* @example
* expect(score).toBeGreaterThanOrEqual(10);
*/
toBeGreaterThanOrEqual: (num: number | bigint) => void;
/**
* For comparing floating point numbers.
*
* @example
* expect(score).toBeLessThan(10);
*/
toBeLessThan: (num: number | bigint) => void;
/**
* For comparing floating point numbers.
*
* @example
* expect(score).toBeLessThanOrEqual(10);
*/
toBeLessThanOrEqual: (num: number | bigint) => void;
/**
* Used to check that a variable is NaN.
*
* @example
* expect(value).toBeNaN();
*/
toBeNaN: () => void;
/**
* Used to check that a variable is undefined.
*
* @example
* expect(value).toBeUndefined();
*/
toBeUndefined: () => void;
/**
* This is the same as `.toBe(null)` but the error messages are a bit nicer.
* So use `.toBeNull()` when you want to check that something is null.
*
* @example
* expect(value).toBeNull();
*/
toBeNull: () => void;
/**
* Used to check that a variable is nullable (null or undefined).
*
* @example
* expect(value).toBeNullable();
*/
toBeNullable: () => void;
/**
* Ensure that a variable is not undefined.
*
* @example
* expect(value).toBeDefined();
*/
toBeDefined: () => void;
/**
* Ensure that an object is an instance of a class.
* This matcher uses `instanceof` underneath.
*
* @example
* expect(new Date()).toBeInstanceOf(Date);
*/
toBeInstanceOf: <E>(expected: E) => void;
/**
* Used to check that an object has a `.length` property
* and it is set to a certain numeric value.
*
* @example
* expect([1, 2, 3]).toHaveLength(3);
* expect('hello').toHaveLength(5);
*/
toHaveLength: (length: number) => void;
/**
* Use to check if a property at the specified path exists on an object.
* For checking deeply nested properties, you may use dot notation or an array containing
* the path segments for deep references.
*
* Optionally, you can provide a value to check if it matches the value present at the path
* on the target object. This matcher uses 'deep equality' (like `toEqual()`) and recursively checks
* the equality of all fields.
*
* @example
* expect(user).toHaveProperty('address.city', 'New York');
* expect(config).toHaveProperty(['settings', 'theme'], 'dark');
*/
toHaveProperty: <E>(property: string | (string | number)[], value?: E) => void;
/**
* Using exact equality with floating point numbers is a bad idea.
* Rounding means that intuitive things fail.
* The default for `numDigits` is 2.
*
* @example
* expect(price).toBeCloseTo(9.99, 2);
*/
toBeCloseTo: (number: number, numDigits?: number) => void;
/**
* Ensures that a mock function is called an exact number of times.
*
* Also under the alias `expect.toBeCalledTimes`.
*
* @example
* expect(mockFunc).toHaveBeenCalledTimes(2);
*/
toHaveBeenCalledTimes: (times: number) => void;
/**
* Ensures that a mock function is called an exact number of times.
*
* Alias for `expect.toHaveBeenCalledTimes`.
*
* @example
* expect(mockFunc).toBeCalledTimes(2);
* @deprecated Use `toHaveBeenCalledTimes` instead
*/
toBeCalledTimes: (times: number) => void;
/**
* Ensures that a mock function is called.
*
* Also under the alias `expect.toBeCalled`.
*
* @example
* expect(mockFunc).toHaveBeenCalled();
*/
toHaveBeenCalled: () => void;
/**
* Ensures that a mock function is called.
*
* Alias for `expect.toHaveBeenCalled`.
*
* @example
* expect(mockFunc).toBeCalled();
* @deprecated Use `toHaveBeenCalled` instead
*/
toBeCalled: () => void;
/**
* Ensure that a mock function is called with specific arguments.
*
* Also under the alias `expect.toBeCalledWith`.
*
* @example
* expect(mockFunc).toHaveBeenCalledWith('arg1', 42);
*/
toHaveBeenCalledWith: <E extends any[]>(...args: E) => void;
/**
* Ensure that a mock function is called with specific arguments.
*
* Alias for `expect.toHaveBeenCalledWith`.
*
* @example
* expect(mockFunc).toBeCalledWith('arg1', 42);
* @deprecated Use `toHaveBeenCalledWith` instead
*/
toBeCalledWith: <E extends any[]>(...args: E) => void;
/**
* Ensure that a mock function is called with specific arguments on an Nth call.
*
* Also under the alias `expect.nthCalledWith`.
*
* @example
* expect(mockFunc).toHaveBeenNthCalledWith(2, 'secondArg');
*/
toHaveBeenNthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
/**
* If you have a mock function, you can use `.toHaveBeenLastCalledWith`
* to test what arguments it was last called with.
*
* Also under the alias `expect.lastCalledWith`.
*
* @example
* expect(mockFunc).toHaveBeenLastCalledWith('lastArg');
*/
toHaveBeenLastCalledWith: <E extends any[]>(...args: E) => void;
/**
* Used to test that a function throws when it is called.
*
* Also under the alias `expect.toThrowError`.
*
* @example
* expect(() => functionWithError()).toThrow('Error message');
* expect(() => parseJSON('invalid')).toThrow(SyntaxError);
* expect(() => { throw 42 }).toThrow(42);
*/
toThrow: (expected?: any) => void;
/**
* Used to test that a function throws when it is called.
*
* Alias for `expect.toThrow`.
*
* @example
* expect(() => functionWithError()).toThrowError('Error message');
* expect(() => parseJSON('invalid')).toThrowError(SyntaxError);
* expect(() => { throw 42 }).toThrowError(42);
* @deprecated Use `toThrow` instead
*/
toThrowError: (expected?: any) => void;
/**
* Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
*
* Alias for `expect.toHaveReturned`.
*
* @example
* expect(mockFunc).toReturn();
* @deprecated Use `toHaveReturned` instead
*/
toReturn: () => void;
/**
* Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
*
* Also under the alias `expect.toReturn`.
*
* @example
* expect(mockFunc).toHaveReturned();
*/
toHaveReturned: () => void;
/**
* Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
* Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
*
* Alias for `expect.toHaveReturnedTimes`.
*
* @example
* expect(mockFunc).toReturnTimes(3);
* @deprecated Use `toHaveReturnedTimes` instead
*/
toReturnTimes: (times: number) => void;
/**
* Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times.
* Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
*
* Also under the alias `expect.toReturnTimes`.
*
* @example
* expect(mockFunc).toHaveReturnedTimes(3);
*/
toHaveReturnedTimes: (times: number) => void;
/**
* Use to ensure that a mock function returned a specific value.
*
* Alias for `expect.toHaveReturnedWith`.
*
* @example
* expect(mockFunc).toReturnWith('returnValue');
* @deprecated Use `toHaveReturnedWith` instead
*/
toReturnWith: <E>(value: E) => void;
/**
* Use to ensure that a mock function returned a specific value.
*
* Also under the alias `expect.toReturnWith`.
*
* @example
* expect(mockFunc).toHaveReturnedWith('returnValue');
*/
toHaveReturnedWith: <E>(value: E) => void;
/**
* Use to test the specific value that a mock function last returned.
* If the last call to the mock function threw an error, then this matcher will fail
* no matter what value you provided as the expected return value.
*
* Also under the alias `expect.lastReturnedWith`.
*
* @example
* expect(mockFunc).toHaveLastReturnedWith('lastValue');
*/
toHaveLastReturnedWith: <E>(value: E) => void;
/**
* Use to test the specific value that a mock function returned for the nth call.
* If the nth call to the mock function threw an error, then this matcher will fail
* no matter what value you provided as the expected return value.
*
* Also under the alias `expect.nthReturnedWith`.
*
* @example
* expect(mockFunc).toHaveNthReturnedWith(2, 'nthValue');
*/
toHaveNthReturnedWith: <E>(nthCall: number, value: E) => void;
}
type VitestAssertion<
A,
T
> = { [K in keyof A] : A[K] extends Chai.Assertion ? Assertion<T> : A[K] extends (...args: any[]) => any ? A[K] : VitestAssertion<A[K], T> } & ((type: string, message?: string) => Assertion);
type Promisify<O> = { [K in keyof O] : O[K] extends (...args: infer A) => infer R ? Promisify<O[K]> & ((...args: A) => Promise<R>) : O[K] };
type PromisifyAssertion<T> = Promisify<Assertion<T>>;
interface Assertion<T = any> extends VitestAssertion<Chai.Assertion, T>, JestAssertion<T>, ChaiMockAssertion, Matchers<T> {
/**
* Ensures a value is of a specific type.
*
* @example
* expect(value).toBeTypeOf('string');
* expect(number).toBeTypeOf('number');
*/
toBeTypeOf: (expected: "bigint" | "boolean" | "function" | "number" | "object" | "string" | "symbol" | "undefined") => void;
/**
* Asserts that a mock function was called exactly once.
*
* @example
* expect(mockFunc).toHaveBeenCalledOnce();
*/
toHaveBeenCalledOnce: () => void;
/**
* Ensure that a mock function is called with specific arguments and called
* exactly once.
*
* @example
* expect(mockFunc).toHaveBeenCalledExactlyOnceWith('arg1', 42);
*/
toHaveBeenCalledExactlyOnceWith: <E extends any[]>(...args: E) => void;
/**
* This assertion checks if a `Mock` was called before another `Mock`.
* @param mock - A mock function created by `vi.spyOn` or `vi.fn`
* @param failIfNoFirstInvocation - Fail if the first mock was never called
* @example
* const mock1 = vi.fn()
* const mock2 = vi.fn()
*
* mock1()
* mock2()
* mock1()
*
* expect(mock1).toHaveBeenCalledBefore(mock2)
*/
toHaveBeenCalledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
/**
* This assertion checks if a `Mock` was called after another `Mock`.
* @param mock - A mock function created by `vi.spyOn` or `vi.fn`
* @param failIfNoFirstInvocation - Fail if the first mock was never called
* @example
* const mock1 = vi.fn()
* const mock2 = vi.fn()
*
* mock2()
* mock1()
* mock2()
*
* expect(mock1).toHaveBeenCalledAfter(mock2)
*/
toHaveBeenCalledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
/**
* Checks that a promise resolves successfully at least once.
*
* @example
* await expect(promise).toHaveResolved();
*/
toHaveResolved: () => void;
/**
* Checks that a promise resolves to a specific value.
*
* @example
* await expect(promise).toHaveResolvedWith('success');
*/
toHaveResolvedWith: <E>(value: E) => void;
/**
* Ensures a promise resolves a specific number of times.
*
* @example
* expect(mockAsyncFunc).toHaveResolvedTimes(3);
*/
toHaveResolvedTimes: (times: number) => void;
/**
* Asserts that the last resolved value of a promise matches an expected value.
*
* @example
* await expect(mockAsyncFunc).toHaveLastResolvedWith('finalResult');
*/
toHaveLastResolvedWith: <E>(value: E) => void;
/**
* Ensures a specific value was returned by a promise on the nth resolution.
*
* @example
* await expect(mockAsyncFunc).toHaveNthResolvedWith(2, 'secondResult');
*/
toHaveNthResolvedWith: <E>(nthCall: number, value: E) => void;
/**
* Verifies that a promise resolves.
*
* @example
* await expect(someAsyncFunc).resolves.toBe(42);
*/
resolves: PromisifyAssertion<T>;
/**
* Verifies that a promise rejects.
*
* @example
* await expect(someAsyncFunc).rejects.toThrow('error');
*/
rejects: PromisifyAssertion<T>;
}
/**
* Chai-style assertions for spy/mock testing.
* These provide sinon-chai compatible assertion names that delegate to Jest-style implementations.
*/
interface ChaiMockAssertion {
/**
* Checks that a spy was called at least once.
* Chai-style equivalent of `toHaveBeenCalled`.
*
* @example
* expect(spy).to.have.been.called
*/
readonly called: Assertion;
/**
* Checks that a spy was called a specific number of times.
* Chai-style equivalent of `toHaveBeenCalledTimes`.
*
* @example
* expect(spy).to.have.callCount(3)
*/
callCount: (count: number) => void;
/**
* Checks that a spy was called with specific arguments at least once.
* Chai-style equivalent of `toHaveBeenCalledWith`.
*
* @example
* expect(spy).to.have.been.calledWith('arg1', 'arg2')
*/
calledWith: <E extends any[]>(...args: E) => void;
/**
* Checks that a spy was called exactly once.
* Chai-style equivalent of `toHaveBeenCalledOnce`.
*
* @example
* expect(spy).to.have.been.calledOnce
*/
readonly calledOnce: Assertion;
/**
* Checks that a spy was called exactly once with specific arguments.
* Chai-style equivalent of `toHaveBeenCalledExactlyOnceWith`.
*
* @example
* expect(spy).to.have.been.calledOnceWith('arg1', 'arg2')
*/
calledOnceWith: <E extends any[]>(...args: E) => void;
/**
* Checks that the last call to a spy was made with specific arguments.
* Chai-style equivalent of `toHaveBeenLastCalledWith`.
*
* @example
* expect(spy).to.have.been.lastCalledWith('arg1', 'arg2')
*/
lastCalledWith: <E extends any[]>(...args: E) => void;
/**
* Checks that the nth call to a spy was made with specific arguments.
* Chai-style equivalent of `toHaveBeenNthCalledWith`.
*
* @example
* expect(spy).to.have.been.nthCalledWith(2, 'arg1', 'arg2')
*/
nthCalledWith: <E extends any[]>(n: number, ...args: E) => void;
/**
* Checks that a spy returned a specific value at least once.
* Chai-style equivalent of `toHaveReturnedWith`.
*
* @example
* expect(spy).to.have.returned('value')
*/
returned: <E>(value: E) => void;
/**
* Checks that a spy returned a specific value at least once.
* Chai-style equivalent of `toHaveReturnedWith`.
*
* @example
* expect(spy).to.have.returnedWith('value')
*/
returnedWith: <E>(value: E) => void;
/**
* Checks that a spy returned successfully a specific number of times.
* Chai-style equivalent of `toHaveReturnedTimes`.
*
* @example
* expect(spy).to.have.returnedTimes(3)
*/
returnedTimes: (count: number) => void;
/**
* Checks that the last return value of a spy matches the expected value.
* Chai-style equivalent of `toHaveLastReturnedWith`.
*
* @example
* expect(spy).to.have.lastReturnedWith('value')
*/
lastReturnedWith: <E>(value: E) => void;
/**
* Checks that the nth return value of a spy matches the expected value.
* Chai-style equivalent of `toHaveNthReturnedWith`.
*
* @example
* expect(spy).to.have.nthReturnedWith(2, 'value')
*/
nthReturnedWith: <E>(n: number, value: E) => void;
/**
* Checks that a spy was called before another spy.
* Chai-style equivalent of `toHaveBeenCalledBefore`.
*
* @example
* expect(spy1).to.have.been.calledBefore(spy2)
*/
calledBefore: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
/**
* Checks that a spy was called after another spy.
* Chai-style equivalent of `toHaveBeenCalledAfter`.
*
* @example
* expect(spy1).to.have.been.calledAfter(spy2)
*/
calledAfter: (mock: MockInstance, failIfNoFirstInvocation?: boolean) => void;
/**
* Checks that a spy was called exactly twice.
* Chai-style equivalent of `toHaveBeenCalledTimes(2)`.
*
* @example
* expect(spy).to.have.been.calledTwice
*/
readonly calledTwice: Assertion;
/**
* Checks that a spy was called exactly three times.
* Chai-style equivalent of `toHaveBeenCalledTimes(3)`.
*
* @example
* expect(spy).to.have.been.calledThrice
*/
readonly calledThrice: Assertion;
}
declare global {
namespace jest {
interface Matchers<
R,
T = {}
> {}
}
}
declare const ChaiStyleAssertions: ChaiPlugin;
declare const MATCHERS_OBJECT: unique symbol;
declare const JEST_MATCHERS_OBJECT: unique symbol;
declare const GLOBAL_EXPECT: unique symbol;
declare const ASYMMETRIC_MATCHERS_OBJECT: unique symbol;
declare const customMatchers: MatchersObject;
declare const JestChaiExpect: ChaiPlugin;
declare const JestExtend: ChaiPlugin;
declare function equals(a: unknown, b: unknown, customTesters?: Array<Tester>, strictCheck?: boolean): boolean;
declare function isAsymmetric(obj: any): obj is AsymmetricMatcher<any>;
declare function hasAsymmetric(obj: any, seen?: Set<any>): boolean;
declare function isError(value: unknown): value is Error;
declare function isA(typeName: string, value: unknown): boolean;
declare function fnNameFor(func: Function): string;
declare function hasProperty(obj: object | null, property: string): boolean;
declare function isImmutableUnorderedKeyed(maybeKeyed: any): boolean;
declare function isImmutableUnorderedSet(maybeSet: any): boolean;
declare function iterableEquality(a: any, b: any, customTesters?: Array<Tester>, aStack?: Array<any>, bStack?: Array<any>): boolean | undefined;
declare function subsetEquality(object: unknown, subset: unknown, customTesters?: Array<Tester>): boolean | undefined;
declare function typeEquality(a: any, b: any): boolean | undefined;
declare function arrayBufferEquality(a: unknown, b: unknown): boolean | undefined;
declare function sparseArrayEquality(a: unknown, b: unknown, customTesters?: Array<Tester>): boolean | undefined;
declare function generateToBeMessage(deepEqualityName: string, expected?: string, actual?: string): string;
declare function pluralize(word: string, count: number): string;
declare function getObjectKeys(object: object): Array<string | symbol>;
declare function getObjectSubset(object: any, subset: any, customTesters: Array<Tester>): {
subset: any;
stripped: number;
};
/**
* Detects if an object is a Standard Schema V1 compatible schema
*/
declare function isStandardSchema(obj: any): obj is StandardSchemaV1;
declare function getState<State extends MatcherState = MatcherState>(expect: ExpectStatic): State;
declare function setState<State extends MatcherState = MatcherState>(state: Partial<State>, expect: ExpectStatic): void;
declare function createAssertionMessage(util: Chai.ChaiUtils, assertion: Chai.Assertion, hasArgs: boolean): string;
declare function recordAsyncExpect(_test: any, promise: Promise<any>, assertion: string, error: Error, isSoft?: boolean): Promise<any>;
/** wrap assertion function to support `expect.soft` and provide assertion name as `_name` */
declare function wrapAssertion(utils: Chai.ChaiUtils, name: string, fn: (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>): (this: Chai.AssertionStatic & Assertion, ...args: any[]) => void | PromiseLike<void>;
export { ASYMMETRIC_MATCHERS_OBJECT, Any, Anything, ArrayContaining, AsymmetricMatcher, ChaiStyleAssertions, GLOBAL_EXPECT, JEST_MATCHERS_OBJECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, MATCHERS_OBJECT, ObjectContaining, SchemaMatching, StringContaining, StringMatching, addCustomEqualityTesters, arrayBufferEquality, createAssertionMessage, customMatchers, equals, fnNameFor, generateToBeMessage, getObjectKeys, getObjectSubset, getState, hasAsymmetric, hasProperty, isA, isAsymmetric, isError, isImmutableUnorderedKeyed, isImmutableUnorderedSet, isStandardSchema, iterableEquality, pluralize, recordAsyncExpect, setState, sparseArrayEquality, subsetEquality, typeEquality, wrapAssertion };
export type { Assertion, AsymmetricMatcherInterface, AsymmetricMatchersContaining, AsyncExpectationResult, ChaiMockAssertion, ChaiPlugin, DeeplyAllowMatchers, ExpectStatic, ExpectationResult, JestAssertion, MatcherHintOptions, MatcherState, Matchers, MatchersObject, PromisifyAssertion, RawMatcherFn, SyncExpectationResult, Tester, TesterContext };
.pnpm-store/v11/files/58/2e97f025cb601a78798731e11c7b6b1686b853c4c19dcfe9f8fb30f98b9b7f768ac77f4a080ff81552ac98f37e5795c8950e3fef999c8d84ce15aa8ce6003a
+14
View File
@@ -0,0 +1,14 @@
import { DictionaryMatch, MatchOptions } from '../../types'
export interface DictionaryMatchOptionsLevenshtein extends MatchOptions {
useLevenshtein?: boolean
}
export type DictionaryMatchOptions = Pick<
DictionaryMatchOptionsLevenshtein,
'password' | 'userInputsOptions' | 'useLevenshtein'
>
export type DefaultMatch = (
options: DictionaryMatchOptions,
) => DictionaryMatch[]
.pnpm-store/v11/files/58/326c7b6d9c5c67e4ae7954a1fec0d934736dce2167df82f6af112c896a55dacf7fa2cc40233316560040e3ab14bb3c252abfbdc7316b5f8a1e573c2bb62fdc
+119
View File
@@ -0,0 +1,119 @@
import { importJWK } from '../key/import.js';
import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
import { isObject } from '../lib/type_checks.js';
function getKtyFromAlg(alg) {
switch (typeof alg === 'string' && alg.slice(0, 2)) {
case 'RS':
case 'PS':
return 'RSA';
case 'ES':
return 'EC';
case 'Ed':
return 'OKP';
case 'ML':
return 'AKP';
default:
throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
}
}
function isJWKSLike(jwks) {
return (jwks &&
typeof jwks === 'object' &&
Array.isArray(jwks.keys) &&
jwks.keys.every(isJWKLike));
}
function isJWKLike(key) {
return isObject(key);
}
class LocalJWKSet {
#jwks;
#cached = new WeakMap();
constructor(jwks) {
if (!isJWKSLike(jwks)) {
throw new JWKSInvalid('JSON Web Key Set malformed');
}
this.#jwks = structuredClone(jwks);
}
jwks() {
return this.#jwks;
}
async getKey(protectedHeader, token) {
const { alg, kid } = { ...protectedHeader, ...token?.header };
const kty = getKtyFromAlg(alg);
const candidates = this.#jwks.keys.filter((jwk) => {
let candidate = kty === jwk.kty;
if (candidate && typeof kid === 'string') {
candidate = kid === jwk.kid;
}
if (candidate && (typeof jwk.alg === 'string' || kty === 'AKP')) {
candidate = alg === jwk.alg;
}
if (candidate && typeof jwk.use === 'string') {
candidate = jwk.use === 'sig';
}
if (candidate && Array.isArray(jwk.key_ops)) {
candidate = jwk.key_ops.includes('verify');
}
if (candidate) {
switch (alg) {
case 'ES256':
candidate = jwk.crv === 'P-256';
break;
case 'ES384':
candidate = jwk.crv === 'P-384';
break;
case 'ES512':
candidate = jwk.crv === 'P-521';
break;
case 'Ed25519':
case 'EdDSA':
candidate = jwk.crv === 'Ed25519';
break;
}
}
return candidate;
});
const { 0: jwk, length } = candidates;
if (length === 0) {
throw new JWKSNoMatchingKey();
}
if (length !== 1) {
const error = new JWKSMultipleMatchingKeys();
const _cached = this.#cached;
error[Symbol.asyncIterator] = async function* () {
for (const jwk of candidates) {
try {
yield await importWithAlgCache(_cached, jwk, alg);
}
catch { }
}
};
throw error;
}
return importWithAlgCache(this.#cached, jwk, alg);
}
}
async function importWithAlgCache(cache, jwk, alg) {
const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
if (cached[alg] === undefined) {
const key = await importJWK({ ...jwk, ext: true }, alg);
if (key instanceof Uint8Array || key.type !== 'public') {
throw new JWKSInvalid('JSON Web Key Set members must be public keys');
}
cached[alg] = key;
}
return cached[alg];
}
export function createLocalJWKSet(jwks) {
const set = new LocalJWKSet(jwks);
const localJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
Object.defineProperties(localJWKSet, {
jwks: {
value: () => structuredClone(set.jwks()),
enumerable: false,
configurable: false,
writable: false,
},
});
return localJWKSet;
}
.pnpm-store/v11/files/58/336177400ecf46082a1ec53d342eacec6324e246fcd87d640e15dbda81d5880f4d61d1dde77bc7a3c304c9b691563f9cfe74c5db8b351545cfd7f34f52191e
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"folder-heart.js","sources":["../../../src/icons/folder-heart.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name FolderHeart\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTEgMjBINGEyIDIgMCAwIDEtMi0yVjVhMiAyIDAgMCAxIDItMmgzLjlhMiAyIDAgMCAxIDEuNjkuOWwuODEgMS4yYTIgMiAwIDAgMCAxLjY3LjlIMjBhMiAyIDAgMCAxIDIgMnYxLjUiIC8+CiAgPHBhdGggZD0iTTEzLjkgMTcuNDVjLTEuMi0xLjItMS4xNC0yLjgtLjItMy43M2EyLjQzIDIuNDMgMCAwIDEgMy40NCAwbC4zNi4zNC4zNC0uMzRhMi40MyAyLjQzIDAgMCAxIDMuNDUtLjAxYy45NS45NSAxIDIuNTMtLjIgMy43NEwxNy41IDIxWiIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/folder-heart\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst FolderHeart = createLucideIcon('FolderHeart', [\n [\n 'path',\n {\n d: 'M11 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v1.5',\n key: '6hud8k',\n },\n ],\n [\n 'path',\n {\n d: 'M13.9 17.45c-1.2-1.2-1.14-2.8-.2-3.73a2.43 2.43 0 0 1 3.44 0l.36.34.34-.34a2.43 2.43 0 0 1 3.45-.01c.95.95 1 2.53-.2 3.74L17.5 21Z',\n key: 'wpff58',\n },\n ],\n]);\n\nexport default FolderHeart;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAc,iBAAiB,aAAe,CAAA,CAAA,CAAA;AAAA,CAClD,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA;AACF,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/3394e84d561ee59bf898869b035bf3011266ebe562eda90277a3ee4ed3f72d57e5471dc18118ba4013d59f5b1793d3dc01a6838cec1eee6a775ab43718b192
+7
View File
@@ -0,0 +1,7 @@
{
"version": 3,
"sources": ["../src/use-callback-ref.tsx"],
"sourcesContent": ["import * as React from 'react';\n\n/**\n * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a\n * prop or avoid re-executing effects when passed as a dependency\n */\nfunction useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T {\n const callbackRef = React.useRef(callback);\n\n React.useEffect(() => {\n callbackRef.current = callback;\n });\n\n // https://github.com/facebook/react/issues/19240\n return React.useMemo(() => ((...args) => callbackRef.current?.(...args)) as T, []);\n}\n\nexport { useCallbackRef };\n"],
"mappings": ";AAAA,YAAY,WAAW;AAMvB,SAAS,eAAkD,UAA4B;AACrF,QAAM,cAAoB,aAAO,QAAQ;AAEzC,EAAM,gBAAU,MAAM;AACpB,gBAAY,UAAU;AAAA,EACxB,CAAC;AAGD,SAAa,cAAQ,MAAO,IAAI,SAAS,YAAY,UAAU,GAAG,IAAI,GAAS,CAAC,CAAC;AACnF;",
"names": []
}
.pnpm-store/v11/files/58/34b1d900b88703f7c444b5204cc433e07c71a8d9b7e49ff67592f450c1a7237d7403be81d287cc0e5aee13770f6755e09c2258486904dc5b4168b85598dbbd
+7
View File
@@ -0,0 +1,7 @@
/**
* A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a
* prop or avoid re-executing effects when passed as a dependency
*/
declare function useCallbackRef<T extends (...args: any[]) => any>(callback: T | undefined): T;
export { useCallbackRef };
.pnpm-store/v11/files/58/355894e6a1ee5dad90db9350dc015c5027396cd83987a94bfa4f53e50b1da294ab1933afdb380b51f34b81d7086b3b65c3e0ddd726f83db951753a1adb0ba0
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"DOMKeyframesResolver.mjs","sources":["../../../../src/animation/keyframes/DOMKeyframesResolver.ts"],"sourcesContent":["import { positionalKeys } from \"../../render/utils/keys-position\"\nimport { MotionValue } from \"../../value\"\nimport { findDimensionValueType } from \"../../value/types/dimensions\"\nimport { AnyResolvedKeyframe } from \"../types\"\nimport { getVariableValue } from \"../utils/css-variables-conversion\"\nimport {\n containsCSSVariable,\n isCSSVariableToken,\n} from \"../utils/is-css-variable\"\nimport {\n KeyframeResolver,\n OnKeyframesResolved,\n UnresolvedKeyframes,\n} from \"./KeyframesResolver\"\nimport { WithRender } from \"./types\"\nimport { isNone } from \"./utils/is-none\"\nimport { makeNoneKeyframesAnimatable } from \"./utils/make-none-animatable\"\nimport { isNumOrPxType, positionalValues } from \"./utils/unit-conversion\"\n\nexport class DOMKeyframesResolver<\n T extends AnyResolvedKeyframe\n> extends KeyframeResolver<T> {\n name: string\n element?: WithRender\n\n private removedTransforms?: [string, AnyResolvedKeyframe][]\n private measuredOrigin?: AnyResolvedKeyframe\n\n constructor(\n unresolvedKeyframes: UnresolvedKeyframes<AnyResolvedKeyframe>,\n onComplete: OnKeyframesResolved<T>,\n name?: string,\n motionValue?: MotionValue<T>,\n element?: WithRender\n ) {\n super(unresolvedKeyframes, onComplete, name, motionValue, element, true)\n }\n\n readKeyframes() {\n const { unresolvedKeyframes, element, name } = this\n\n if (!element || !element.current) return\n\n super.readKeyframes()\n\n /**\n * If any keyframe is a CSS variable, we need to find its value by sampling the element\n */\n for (let i = 0; i < unresolvedKeyframes.length; i++) {\n let keyframe = unresolvedKeyframes[i]\n\n if (typeof keyframe === \"string\") {\n keyframe = keyframe.trim()\n\n if (isCSSVariableToken(keyframe)) {\n const resolved = getVariableValue(keyframe, element.current)\n\n if (resolved !== undefined) {\n unresolvedKeyframes[i] = resolved as T\n }\n\n if (i === unresolvedKeyframes.length - 1) {\n this.finalKeyframe = keyframe as T\n }\n }\n }\n }\n\n /**\n * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n * have a far bigger performance impact.\n */\n this.resolveNoneKeyframes()\n\n /**\n * Check to see if unit type has changed. If so schedule jobs that will\n * temporarily set styles to the destination keyframes.\n * Skip if we have more than two keyframes or this isn't a positional value.\n * TODO: We can throw if there are multiple keyframes and the value type changes.\n */\n if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n return\n }\n\n const [origin, target] = unresolvedKeyframes\n const originType = findDimensionValueType(origin)\n const targetType = findDimensionValueType(target)\n\n /**\n * If one keyframe contains embedded CSS variables (e.g. in calc()) and the other\n * doesn't, we need to measure to convert to pixels. This handles GitHub issue #3410.\n */\n const originHasVar = containsCSSVariable(origin)\n const targetHasVar = containsCSSVariable(target)\n\n if (originHasVar !== targetHasVar && positionalValues[name]) {\n this.needsMeasurement = true\n return\n }\n\n /**\n * Either we don't recognise these value types or we can animate between them.\n */\n if (originType === targetType) return\n\n /**\n * If both values are numbers or pixels, we can animate between them by\n * converting them to numbers.\n */\n if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n for (let i = 0; i < unresolvedKeyframes.length; i++) {\n const value = unresolvedKeyframes[i]\n if (typeof value === \"string\") {\n unresolvedKeyframes[i] = parseFloat(value as string)\n }\n }\n } else if (positionalValues[name]) {\n /**\n * Else, the only way to resolve this is by measuring the element.\n */\n this.needsMeasurement = true\n }\n }\n\n resolveNoneKeyframes() {\n const { unresolvedKeyframes, name } = this\n\n const noneKeyframeIndexes: number[] = []\n for (let i = 0; i < unresolvedKeyfrLine truncated
.pnpm-store/v11/files/58/35f93c07e34f6ac32cc8b51bd0a2c44e3252ed07e70690782ac99d680cad46047454cc6992553a6f90243a5e23c455f0403becc986c0e782554e246580d338
+17
View File
@@ -0,0 +1,17 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const FileLock = createLucideIcon("FileLock", [
["path", { d: "M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z", key: "1rqfz7" }],
["rect", { width: "8", height: "6", x: "8", y: "12", rx: "1", key: "3yr8at" }],
["path", { d: "M10 12v-2a2 2 0 1 1 4 0v2", key: "j4i8d" }]
]);
export { FileLock as default };
//# sourceMappingURL=file-lock.js.map
.pnpm-store/v11/files/58/3d288a74d9a5ba410dbda8924188822acc7cd0ae060f9535ed49a1e386424e332878a1efc77be8bc154cafb967c01aacafe6c1d905dfaf79699e72d46f7a09
+2
View File
@@ -0,0 +1,2 @@
export declare function cleanUrl(url: string): string;
export declare function extractQueryWithoutFragment(url: string): string;
.pnpm-store/v11/files/58/40f3f6484aa1bc1f578f7c37c947248584faca257fe18ea0a75cae45dc9a6d9e70190b6a9ff4984ed3daf577dfb5e809f0362cebd0b9ae12f23d7976b38935
+62
View File
@@ -0,0 +1,62 @@
export {};
import * as undici from "undici-types";
type _CloseEvent = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEvent;
type _CloseEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.CloseEventInit;
type _EventSource = typeof globalThis extends { onmessage: any } ? {} : undici.EventSource;
type _EventSourceInit = typeof globalThis extends { onmessage: any } ? {} : undici.EventSourceInit;
type _FormData = typeof globalThis extends { onmessage: any } ? {} : undici.FormData;
type _Headers = typeof globalThis extends { onmessage: any } ? {} : undici.Headers;
type _MessageEvent = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEvent;
type _MessageEventInit = typeof globalThis extends { onmessage: any } ? {} : undici.MessageEventInit;
type _Request = typeof globalThis extends { onmessage: any } ? {} : undici.Request;
type _RequestInit = typeof globalThis extends { onmessage: any } ? {} : undici.RequestInit;
type _Response = typeof globalThis extends { onmessage: any } ? {} : undici.Response;
type _ResponseInit = typeof globalThis extends { onmessage: any } ? {} : undici.ResponseInit;
type _WebSocket = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocket;
type _WebSocketInit = typeof globalThis extends { onmessage: any } ? {} : undici.WebSocketInit;
declare global {
function fetch(
input: string | URL | Request,
init?: RequestInit,
): Promise<Response>;
interface CloseEvent extends _CloseEvent {}
var CloseEvent: typeof globalThis extends { onmessage: any; CloseEvent: infer T } ? T : typeof undici.CloseEvent;
interface CloseEventInit extends _CloseEventInit {}
interface EventSource extends _EventSource {}
var EventSource: typeof globalThis extends { onmessage: any; EventSource: infer T } ? T : typeof undici.EventSource;
interface EventSourceInit extends _EventSourceInit {}
interface FormData extends _FormData {}
var FormData: typeof globalThis extends { onmessage: any; FormData: infer T } ? T : typeof undici.FormData;
interface Headers extends _Headers {}
var Headers: typeof globalThis extends { onmessage: any; Headers: infer T } ? T : typeof undici.Headers;
interface MessageEvent extends _MessageEvent {}
var MessageEvent: typeof globalThis extends { onmessage: any; MessageEvent: infer T } ? T
: typeof undici.MessageEvent;
interface MessageEventInit extends _MessageEventInit {}
interface Request extends _Request {}
var Request: typeof globalThis extends { onmessage: any; Request: infer T } ? T : typeof undici.Request;
interface RequestInit extends _RequestInit {}
interface Response extends _Response {}
var Response: typeof globalThis extends { onmessage: any; Response: infer T } ? T : typeof undici.Response;
interface ResponseInit extends _ResponseInit {}
interface WebSocket extends _WebSocket {}
var WebSocket: typeof globalThis extends { onmessage: any; WebSocket: infer T } ? T : typeof undici.WebSocket;
interface WebSocketInit extends _WebSocketInit {}
}
.pnpm-store/v11/files/58/47ad57d5c5fa79705b53dfeb95553da298465e65e74cf5924c5eafa7dd07d7272a75c6553363a4f452d759b3215619da0b7a495e7abac23ed1c0d596629a23
+465
View File
@@ -0,0 +1,465 @@
// Generated by LiveScript 1.6.0
(function(){
var VERSION, ref$, id, map, compact, any, groupBy, partition, chars, isItNaN, keys, Obj, camelize, deepIs, closestString, nameToRaw, dasherize, naturalJoin, generateHelp, generateHelpForOption, parsedTypeCheck, parseType, parseLevn, camelizeKeys, parseString, main, toString$ = {}.toString, slice$ = [].slice, arrayFrom$ = Array.from || function(x){return slice$.call(x);};
VERSION = '0.9.4';
ref$ = require('prelude-ls'), id = ref$.id, map = ref$.map, compact = ref$.compact, any = ref$.any, groupBy = ref$.groupBy, partition = ref$.partition, chars = ref$.chars, isItNaN = ref$.isItNaN, keys = ref$.keys, Obj = ref$.Obj, camelize = ref$.camelize;
deepIs = require('deep-is');
ref$ = require('./util'), closestString = ref$.closestString, nameToRaw = ref$.nameToRaw, dasherize = ref$.dasherize, naturalJoin = ref$.naturalJoin;
ref$ = require('./help'), generateHelp = ref$.generateHelp, generateHelpForOption = ref$.generateHelpForOption;
ref$ = require('type-check'), parsedTypeCheck = ref$.parsedTypeCheck, parseType = ref$.parseType;
parseLevn = require('levn').parsedTypeParse;
camelizeKeys = function(obj){
var key, value, resultObj$ = {};
for (key in obj) {
value = obj[key];
resultObj$[camelize(key)] = value;
}
return resultObj$;
};
parseString = function(string){
var assignOpt, regex, replaceRegex, result;
assignOpt = '--?[a-zA-Z][-a-z-A-Z0-9]*=';
regex = RegExp('(?:' + assignOpt + ')?(?:\'(?:\\\\\'|[^\'])+\'|"(?:\\\\"|[^"])+")|[^\'"\\s]+', 'g');
replaceRegex = RegExp('^(' + assignOpt + ')?[\'"]([\\s\\S]*)[\'"]$');
result = map(function(it){
return it.replace(replaceRegex, '$1$2');
}, string.match(regex) || []);
return result;
};
main = function(libOptions){
var opts, defaults, required, traverse, getOption, parse;
opts = {};
defaults = {};
required = [];
if (toString$.call(libOptions.stdout).slice(8, -1) === 'Undefined') {
libOptions.stdout = process.stdout;
}
libOptions.positionalAnywhere == null && (libOptions.positionalAnywhere = true);
libOptions.typeAliases == null && (libOptions.typeAliases = {});
libOptions.defaults == null && (libOptions.defaults = {});
if (libOptions.concatRepeatedArrays != null) {
libOptions.defaults.concatRepeatedArrays = libOptions.concatRepeatedArrays;
}
if (libOptions.mergeRepeatedObjects != null) {
libOptions.defaults.mergeRepeatedObjects = libOptions.mergeRepeatedObjects;
}
traverse = function(options){
var i$, len$, option, name, k, ref$, v, type, that, e, parsedPossibilities, parsedType, j$, len1$, possibility, rawDependsType, dependsOpts, dependsType, cra, alias, shortNames, longNames;
if (toString$.call(options).slice(8, -1) !== 'Array') {
throw new Error('No options defined.');
}
for (i$ = 0, len$ = options.length; i$ < len$; ++i$) {
option = options[i$];
if (option.heading == null) {
name = option.option;
if (opts[name] != null) {
throw new Error("Option '" + name + "' already defined.");
}
for (k in ref$ = libOptions.defaults) {
v = ref$[k];
option[k] == null && (option[k] = v);
}
if (option.type === 'Boolean') {
option.boolean == null && (option.boolean = true);
}
if (option.parsedType == null) {
if (!option.type) {
throw new Error("No type defined for option '" + name + "'.");
}
try {
type = (that = libOptions.typeAliases[option.type]) != null
? that
: option.type;
option.parsedType = parseType(type);
} catch (e$) {
e = e$;
throw new Error("Option '" + name + "': Error parsing type '" + option.type + "': " + e.message);
}
}
if (option['default']) {
try {
defaults[name] = parseLevn(option.parsedType, option['default']);
} catch (e$) {
e = e$;
throw new Error("Option '" + name + "': Error parsing default value '" + option['default'] + "' for type '" + option.type + "': " + e.message);
}
}
if (option['enum'] && !option.parsedPossiblities) {
parsedPossibilities = [];
parsedType = option.parsedType;
for (j$ = 0, len1$ = (ref$ = option['enum']).length; j$ < len1$; ++j$) {
possibility = ref$[j$];
try {
parsedPossibilities.push(parseLevn(parsedType, possibility));
} catch (e$) {
e = e$;
throw new Error("Option '" + name + "': Error parsing enum value '" + possibility + "' for type '" + option.type + "': " + e.message);
}
}
option.parsedPossibilities = parsedPossibilities;
}
if (that = option.dependsOn) {
if (that.length) {
ref$ = [].concat(option.dependsOn), rawDependsType = ref$[0], dependsOpts = slice$.call(ref$, 1);
dependsType = rawDependsType.toLowerCase();
if (dependsOpts.length) {
if (dependsType === 'and' || dependsType === 'or') {
option.dependsOn = [dependsType].concat(arrayFrom$(dependsOpts));
} else {
throw new Error("Option '" + name + "': If you have more than one dependency, you must specify either 'and' or 'or'");
}
} else {
if ((ref$ = dependsType.toLowerCase()) === 'and' || ref$ === 'or') {
option.dependsOn = null;
} else {
option.dependsOn = ['and', rawDependsType];
}
}
} else {
option.dependsOn = null;
}
}
if (option.required) {
required.push(name);
}
opts[name] = option;
if (option.concatRepeatedArrays != null) {
cra = option.concatRepeatedArrays;
if ('Boolean' === toString$.call(cra).slice(8, -1)) {
option.concatRepeatedArrays = [cra, {}];
} else if (cra.length === 1) {
option.concatRepeatedArrays = [cra[0], {}];
} else if (cra.length !== 2) {
throw new Error("Invalid setting for concatRepeatedArrays");
}
}
if (option.alias || option.aliases) {
if (name === 'NUM') {
throw new Error("-NUM option can't have aliases.");
}
if (option.alias) {
option.aliases == null && (option.aliases = [].concat(option.alias));
}
for (j$ = 0, len1$ = (ref$ = option.aliases).length; j$ < len1$; ++j$) {
alias = ref$[j$];
if (opts[alias] != null) {
throw new Error("Option '" + alias + "' already defined.");
}
opts[alias] = option;
}
ref$ = partition(fn$, option.aliases), shortNames = ref$[0], longNames = ref$[1];
option.shortNames == null && (option.shortNames = shortNames);
option.longNames == null && (option.longNames = longNames);
}
if ((!option.aliases || option.shortNames.length === 0) && option.type === 'Boolean' && option['default'] === 'true') {
option.negateName = true;
}
}
}
function fn$(it){
return it.length === 1;
}
};
traverse(libOptions.options);
getOption = function(name){
var opt, possiblyMeant;
opt = opts[name];
if (opt == null) {
possiblyMeant = closestString(keys(opts), name);
throw new Error("Invalid option '" + nameToRaw(name) + "'" + (possiblyMeant ? " - perhaps you meant '" + nameToRaw(possiblyMeant) + "'?" : '.'));
}
return opt;
};
parse = function(input, arg$){
var slice, obj, positional, restPositional, overrideRequired, prop, setValue, setDefaults, checkRequired, mutuallyExclusiveError, checkMutuallyExclusive, checkDependency, checkDependencies, checkProp, args, key, value, option, ref$, i$, len$, arg, that, result, short, argName, usingAssign, val, flags, len, j$, len1$, i, flag, opt, name, valPrime, negated, noedName;
slice = (arg$ != null
? arg$
: {}).slice;
obj = {};
positional = [];
restPositional = false;
overrideRequired = false;
prop = null;
setValue = function(name, value){
var opt, val, cra, e, currentType;
opt = getOption(name);
if (opt.boolean) {
val = value;
} else {
try {
cra = opt.concatRepeatedArrays;
if (cra != null && cra[0] && cra[1].oneValuePerFlag && opt.parsedType.length === 1 && opt.parsedType[0].structure === 'array') {
val = [parseLevn(opt.parsedType[0].of, value)];
} else {
val = parseLevn(opt.parsedType, value);
}
} catch (e$) {
e = e$;
throw new Error("Invalid value for option '" + name + "' - expected type " + opt.type + ", received value: " + value + ".");
}
if (opt['enum'] && !any(function(it){
return deepIs(it, val);
}, opt.parsedPossibilities)) {
throw new Error("Option " + name + ": '" + val + "' not one of " + naturalJoin(opt['enum']) + ".");
}
}
currentType = toString$.call(obj[name]).slice(8, -1);
if (obj[name] != null) {
if (opt.concatRepeatedArrays != null && opt.concatRepeatedArrays[0] && currentType === 'Array') {
obj[name] = obj[name].concat(val);
} else if (opt.mergeRepeatedObjects && currentType === 'Object') {
import$(obj[name], val);
} else {
obj[name] = val;
}
} else {
obj[name] = val;
}
if (opt.restPositional) {
restPositional = true;
}
if (opt.overrideRequired) {
overrideRequired = true;
}
};
setDefaults = function(){
var name, ref$, value;
for (name in ref$ = defaults) {
value = ref$[name];
if (obj[name] == null) {
obj[name] = value;
}
}
};
checkRequired = function(){
var i$, ref$, len$, name;
if (overrideRequired) {
return;
}
for (i$ = 0, len$ = (ref$ = required).length; i$ < len$; ++i$) {
name = ref$[i$];
if (!obj[name]) {
throw new Error("Option " + nameToRaw(name) + " is required.");
}
}
};
mutuallyExclusiveError = function(first, second){
throw new Error("The options " + nameToRaw(first) + " and " + nameToRaw(second) + " are mutually exclusive - you cannot use them at the same time.");
};
checkMutuallyExclusive = function(){
var rules, i$, len$, rule, present, j$, len1$, element, k$, len2$, opt;
rules = libOptions.mutuallyExclusive;
if (!rules) {
return;
}
for (i$ = 0, len$ = rules.length; i$ < len$; ++i$) {
rule = rules[i$];
present = null;
for (j$ = 0, len1$ = rule.length; j$ < len1$; ++j$) {
element = rule[j$];
if (toString$.call(element).slice(8, -1) === 'Array') {
for (k$ = 0, len2$ = element.length; k$ < len2$; ++k$) {
opt = element[k$];
if (opt in obj) {
if (present != null) {
mutuallyExclusiveError(present, opt);
} else {
present = opt;
break;
}
}
}
} else {
if (element in obj) {
if (present != null) {
mutuallyExclusiveError(present, element);
} else {
present = element;
}
}
}
}
}
};
checkDependency = function(option){
var dependsOn, type, targetOptionNames, i$, len$, targetOptionName, targetOption;
dependsOn = option.dependsOn;
if (!dependsOn || option.dependenciesMet) {
return true;
}
type = dependsOn[0], targetOptionNames = slice$.call(dependsOn, 1);
for (i$ = 0, len$ = targetOptionNames.length; i$ < len$; ++i$) {
targetOptionName = targetOptionNames[i$];
targetOption = obj[targetOptionName];
if (targetOption && checkDependency(targetOption)) {
if (type === 'or') {
return true;
}
} else if (type === 'and') {
throw new Error("The option '" + option.option + "' did not have its dependencies met.");
}
}
if (type === 'and') {
return true;
} else {
throw new Error("The option '" + option.option + "' did not meet any of its dependencies.");
}
};
checkDependencies = function(){
var name;
for (name in obj) {
checkDependency(opts[name]);
}
};
checkProp = function(){
if (prop) {
throw new Error("Value for '" + prop + "' of type '" + getOption(prop).type + "' required.");
}
};
switch (toString$.call(input).slice(8, -1)) {
case 'String':
args = parseString(input.slice(slice != null ? slice : 0));
break;
case 'Array':
args = input.slice(slice != null ? slice : 2);
break;
case 'Object':
obj = {};
for (key in input) {
value = input[key];
if (key !== '_') {
option = getOption(dasherize(key));
if (parsedTypeCheck(option.parsedType, value)) {
obj[option.option] = value;
} else {
throw new Error("Option '" + option.option + "': Invalid type for '" + value + "' - expected type '" + option.type + "'.");
}
}
}
checkMutuallyExclusive();
checkDependencies();
setDefaults();
checkRequired();
return ref$ = camelizeKeys(obj), ref$._ = input._ || [], ref$;
default:
throw new Error("Invalid argument to 'parse': " + input + ".");
}
for (i$ = 0, len$ = args.length; i$ < len$; ++i$) {
arg = args[i$];
if (arg === '--') {
restPositional = true;
} else if (restPositional) {
positional.push(arg);
} else {
if (that = arg.match(/^(--?)([a-zA-Z][-a-zA-Z0-9]*)(=)?(.*)?$/)) {
result = that;
checkProp();
short = result[1].length === 1;
argName = result[2];
usingAssign = result[3] != null;
val = result[4];
if (usingAssign && val == null) {
throw new Error("No value for '" + argName + "' specified.");
}
if (short) {
flags = chars(argName);
len = flags.length;
for (j$ = 0, len1$ = flags.length; j$ < len1$; ++j$) {
i = j$;
flag = flags[j$];
opt = getOption(flag);
name = opt.option;
if (restPositional) {
positional.push(flag);
} else if (i === len - 1) {
if (usingAssign) {
valPrime = opt.boolean ? parseLevn([{
type: 'Boolean'
}], val) : val;
setValue(name, valPrime);
} else if (opt.boolean) {
setValue(name, true);
} else {
prop = name;
}
} else if (opt.boolean) {
setValue(name, true);
} else {
throw new Error("Can't set argument '" + flag + "' when not last flag in a group of short flags.");
}
}
} else {
negated = false;
if (that = argName.match(/^no-(.+)$/)) {
negated = true;
noedName = that[1];
opt = getOption(noedName);
} else {
opt = getOption(argName);
}
name = opt.option;
if (opt.boolean) {
valPrime = usingAssign ? parseLevn([{
type: 'Boolean'
}], val) : true;
if (negated) {
setValue(name, !valPrime);
} else {
setValue(name, valPrime);
}
} else {
if (negated) {
throw new Error("Only use 'no-' prefix for Boolean options, not with '" + noedName + "'.");
}
if (usingAssign) {
setValue(name, val);
} else {
prop = name;
}
}
}
} else if (that = arg.match(/^-([0-9]+(?:\.[0-9]+)?)$/)) {
opt = opts.NUM;
if (!opt) {
throw new Error('No -NUM option defined.');
}
setValue(opt.option, that[1]);
} else {
if (prop) {
setValue(prop, arg);
prop = null;
} else {
positional.push(arg);
if (!libOptions.positionalAnywhere) {
restPositional = true;
}
}
}
}
}
checkProp();
checkMutuallyExclusive();
checkDependencies();
setDefaults();
checkRequired();
return ref$ = camelizeKeys(obj), ref$._ = positional, ref$;
};
return {
parse: parse,
parseArgv: function(it){
return parse(it, {
slice: 2
});
},
generateHelp: generateHelp(libOptions),
generateHelpForOption: generateHelpForOption(getOption, libOptions)
};
};
main.VERSION = VERSION;
module.exports = main;
function import$(obj, src){
var own = {}.hasOwnProperty;
for (var key in src) if (own.call(src, key)) obj[key] = src[key];
return obj;
}
}).call(this);
.pnpm-store/v11/files/58/48070885566482443e0067b6e2c2436be648f7a6f8f0850aa7e73e9b4f2e835943fc1d46d0c353de894b767095d655a7a28dc4fbb92e100da157b7e6ab5331
+1
View File
@@ -0,0 +1 @@
var d=Object.defineProperty;var o=(r,s)=>d(r,"name",{value:s,configurable:!0});import m from"node:module";import{MessageChannel as u}from"node:worker_threads";import{f as g,a as v}from"./register-CFH5oNdT.mjs";import{pathToFileURL as h}from"node:url";const w=o(r=>(s,e)=>{if(!e)throw new Error("The current file path (import.meta.url) must be provided in the second argument of tsImport()");const a=e.startsWith(g)?e:h(e).toString();return import(`tsx://${JSON.stringify({specifier:s,parentURL:a,namespace:r})}`)},"createScopedImport");let l=!1;const E=o(r=>{if(!m.register)throw new Error(`This version of Node.js (${process.version}) does not support module.register(). Please upgrade to Node v18.19 or v20.6 and above.`);if(!l){const{_resolveFilename:t}=m;m._resolveFilename=(p,...c)=>t(v(p),...c),l=!0}const{sourceMapsEnabled:s}=process;process.setSourceMapsEnabled(!0);const{port1:e,port2:a}=new u;m.register(`./esm/index.mjs?${Date.now()}`,{parentURL:import.meta.url,data:{port:a,namespace:r?.namespace,tsconfig:r?.tsconfig},transferList:[a]});const f=r?.onImport,n=f&&(t=>{t.type==="load"&&f(t.url)});n&&(e.on("message",n),e.unref());const i=o(()=>(s===!1&&process.setSourceMapsEnabled(!1),n&&e.off("message",n),e.postMessage("deactivate"),new Promise(t=>{const p=o(c=>{c.type==="deactivated"&&(t(),e.off("message",p))},"onDeactivated");e.on("message",p)})),"unregister");return r?.namespace&&(i.import=w(r.namespace),i.unregister=i),i},"register");export{E as r};
.pnpm-store/v11/files/58/48b28ddaac1af95d658d110ae8c18d309044206b066c575705e0f8b75f4a918fe692e5f90bba6fe2b1c4ef8344c7096c4f7e2ce87f7fb1537b55e0489d75b3
+77
View File
@@ -0,0 +1,77 @@
/*!
* depd
* Copyright(c) 2015 Douglas Christopher Wilson
* MIT Licensed
*/
'use strict'
/**
* Module exports.
* @public
*/
module.exports = depd
/**
* Create deprecate for namespace in caller.
*/
function depd (namespace) {
if (!namespace) {
throw new TypeError('argument namespace is required')
}
function deprecate (message) {
// no-op in browser
}
deprecate._file = undefined
deprecate._ignored = true
deprecate._namespace = namespace
deprecate._traced = false
deprecate._warned = Object.create(null)
deprecate.function = wrapfunction
deprecate.property = wrapproperty
return deprecate
}
/**
* Return a wrapped function in a deprecation message.
*
* This is a no-op version of the wrapper, which does nothing but call
* validation.
*/
function wrapfunction (fn, message) {
if (typeof fn !== 'function') {
throw new TypeError('argument fn must be a function')
}
return fn
}
/**
* Wrap property in a deprecation message.
*
* This is a no-op version of the wrapper, which does nothing but call
* validation.
*/
function wrapproperty (obj, prop, message) {
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
throw new TypeError('argument obj must be object')
}
var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
if (!descriptor) {
throw new TypeError('must call property on owner object')
}
if (!descriptor.configurable) {
throw new TypeError('property must be configurable')
}
}
.pnpm-store/v11/files/58/4c55a4203d9e7518935f05bb4e5017928de76945062d06e096301c1195d3a2ab5204e2d4640fc1a868d4c95c7db75127879ccb52ffa0ff69eac7fe86f923a6
+9
View File
@@ -0,0 +1,9 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
export { default } from './square-chevron-down.js';
//# sourceMappingURL=chevron-down-square.js.map
.pnpm-store/v11/files/58/527efad94910db0e8e57bd46dbb87297ad0aced8e564d7db6e0c3f60d924eb444bc771cc0ff4f03d2cd774bc72c1ebd9b580a8fc5c7e78908cdbc707ff7e03
+1
View File
@@ -0,0 +1 @@
module.exports={A:{A:{"2":"_b","388":"_V"},B:{"4":"_K","260":"_I"},C:{"1":"_tC","2":"GD","4":"fC"},D:{"4":"_Q"},E:{"2":"_e","4":"_DB"},F:{"4":"_c"},G:{"4":"_M"},H:{"2":"1D"},I:{"2":"_W","4":"_X"},J:{"1":"A","2":"D"},K:{"4":"_N"},L:{"4":"I"},M:{"1":"YC"},N:{"2":"_A"},O:{"4":"bC"},P:{"4":"_F"},Q:{"4":"JE"},R:{"4":"KE"},S:{"1":"_C"}},B:2,C:"SVG effects for HTML",D:true};
.pnpm-store/v11/files/58/56f300470ee7c078548136bc5caf74c8a943dd204089b4d2013118219d40984168c31bbbdb448e5ff1c65441e306ac2bcf3cbcabc9afea2bb1dc1cf62885d6
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"monitor-x.js","sources":["../../../src/icons/monitor-x.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name MonitorX\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJtMTQuNSAxMi41LTUtNSIgLz4KICA8cGF0aCBkPSJtOS41IDEyLjUgNS01IiAvPgogIDxyZWN0IHdpZHRoPSIyMCIgaGVpZ2h0PSIxNCIgeD0iMiIgeT0iMyIgcng9IjIiIC8+CiAgPHBhdGggZD0iTTEyIDE3djQiIC8+CiAgPHBhdGggZD0iTTggMjFoOCIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/monitor-x\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst MonitorX = createLucideIcon('MonitorX', [\n ['path', { d: 'm14.5 12.5-5-5', key: '1jahn5' }],\n ['path', { d: 'm9.5 12.5 5-5', key: '1k2t7b' }],\n ['rect', { width: '20', height: '14', x: '2', y: '3', rx: '2', key: '48i651' }],\n ['path', { d: 'M12 17v4', key: '1riwvh' }],\n ['path', { d: 'M8 21h8', key: '1ev6f3' }],\n]);\n\nexport default MonitorX;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAW,iBAAiB,UAAY,CAAA,CAAA,CAAA;AAAA,CAAA,CAC5C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAkB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC/C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAiB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC9C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAO,MAAM,CAAQ,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAM,CAAG,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,GAAG,CAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAI,CAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC9E,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAY,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACzC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC1C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/5a58887eaf468cc203f9561aef0056be4557d72c62f6ea6eb7ef38c1eb69375a59a3fda590820b300f7d0e73f8ae3eee169892c6525b07d93b34b44f0508bf
+1
View File
@@ -0,0 +1 @@
module.exports={C:{"72":0.0013,"101":0.0013,"115":0.0104,"120":0.0143,"121":0.0351,"123":0.0117,"124":0.0039,"125":0.0013,"132":0.0013,"133":0.0013,"140":0.0013,"141":0.0013,"143":0.0013,"144":0.0013,"147":0.0013,"148":0.0104,"149":0.0013,"150":0.0026,"152":0.0039,"153":0.0039,"154":0.0312,"155":0.0689,"156":0.0637,"157":0.0013,_:"2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 102 103 104 105 106 107 108 109 110 111 112 113 114 116 117 118 119 122 126 127 128 129 130 131 134 135 136 137 138 139 142 145 146 151 158 159 160 3.5 3.6"},D:{"41":0.0013,"56":0.0013,"70":0.0013,"71":0.0013,"74":0.0013,"75":0.0013,"83":0.0013,"87":0.0026,"88":0.0013,"91":0.0013,"92":0.0013,"95":0.0013,"101":0.0065,"102":0.0039,"103":0.0715,"104":0.0676,"105":0.0715,"106":0.0689,"107":0.0689,"108":0.0702,"109":0.2132,"110":0.0676,"111":0.0689,"112":0.0689,"114":0.0455,"115":0.0052,"116":0.1326,"117":0.0728,"118":0.0546,"119":0.0572,"120":0.1326,"121":0.0104,"122":0.0221,"123":0.0104,"124":0.0715,"125":0.026,"126":0.0078,"127":0.0052,"128":0.0364,"129":0.0013,"130":0.0039,"131":0.1352,"132":0.0026,"133":0.1495,"134":0.0338,"135":0.0221,"136":0.0273,"137":0.0286,"138":0.091,"139":0.0234,"140":0.0286,"141":0.039,"142":0.0806,"143":0.0065,"144":0.0585,"145":0.0273,"146":0.0468,"147":0.0429,"148":0.0312,"149":0.039,"150":0.1183,"151":0.9295,"152":2.2828,"153":1.3793,"154":0.3458,"155":0.0039,_:"4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 42 43 44 45 46 47 48 49 50 51 52 53 54 55 57 58 59 60 61 62 63 64 65 66 67 68 69 72 73 76 77 78 79 80 81 84 85 86 89 90 93 94 96 97 98 99 100 113 156 157"},F:{"85":0.0013,"89":0.0013,"90":0.0013,"100":0.0039,"101":0.0026,"106":0.0013,"107":0.0026,"113":0.0026,"119":0.0013,"120":0.0013,"121":0.0013,"122":0.0013,"133":0.0208,"134":0.0546,"135":0.0065,_:"9 11 12 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 60 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 86 87 88 91 92 93 94 95 96 97 98 99 102 103 104 105 108 109 110 111 112 114 115 116 117 118 123 124 125 126 127 131 132 9.5-9.6 10.0-10.1 10.5 10.6 11.1 11.5 11.6 12.1"},B:{"92":0.0091,"109":0.0013,"113":0.0013,"114":0.0013,"119":0.0182,"120":0.0156,"122":0.0039,"123":0.0013,"134":0.0013,"136":0.0013,"140":0.0013,"143":0.0013,"144":0.0013,"147":0.0052,"148":0.0026,"149":0.0026,"150":0.0039,"151":0.0182,"152":0.2938,"153":0.234,"154":0.0676,_:"12 13 14 15 16 17 18 79 80 81 83 84 85 86 87 88 89 90 91 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 110 111 112 115 116 117 118 121 124 125 126 127 128 129 130 131 132 133 135 137 138 139 141 142 145 146"},E:{"4":0.0013,"5":0.0013,"27":0.0182,_:"6 7 8 9 10 11 12 13 14 15 3.1 3.2 5.1 6.1 7.1 9.1 10.1 11.1 12.1 15.1 15.2-15.3 15.4 15.5 16.0 16.4 17.0 17.2 17.3 18.4 27.1 27.2 TP","13.1":0.0013,"14.1":0.0013,"15.6":0.0624,"16.1":0.0026,"16.2":0.0013,"16.3":0.0299,"16.5":0.0052,"16.6":0.0832,"17.1":0.0143,"17.4":0.0039,"17.5":0.0026,"17.6":0.0208,"18.0":0.0013,"18.1":0.0013,"18.2":0.0013,"18.3":0.0039,"18.5-18.7":0.0117,"26.0":0.0026,"26.1":0.0039,"26.2":0.0117,"26.3":0.0091,"26.4":0.0104,"26.5":0.0429,"26.6":0.1833},G:{"8":0,"3.2":0,"4.0-4.1":0,"4.2-4.3":0.00181,"5.0-5.1":0.00181,"6.0-6.1":0,"7.0-7.1":0.00362,"8.1-8.4":0,"9.0-9.2":0,"9.3":0,"10.0-10.2":0,"10.3":0.0181,"11.0-11.2":0.00181,"11.3-11.4":0.00362,"12.0-12.1":0,"12.2-12.5":0.04707,"13.0-13.1":0,"13.2":0.00905,"13.3":0,"13.4-13.7":0.00181,"14.0-14.4":0.00724,"14.5-14.8":0.01086,"15.0-15.1":0.01086,"15.2-15.3":0.00724,"15.4":0.00905,"15.5":0.01086,"15.6-15.8":0.23536,"16.0":0.0181,"16.1":0.03259,"16.2":0.0181,"16.3":0.03983,"16.4":0.00905,"16.5":0.01448,"16.6-16.7":0.3277,"17.0":0.01267,"17.1":0.0181,"17.2":0.0181,"17.3":0.02716,"17.4":0.03802,"17.5":0.07423,"17.6-17.7":0.19191,"18.0":0.03983,"18.1":0.07966,"18.2":0.10863,"18.3":0.18829,"18.4":0.11768,"18.5-18.7":2.43146,"26.0":0.11768,"26.1":0.11949,"26.2":0.3114,"26.3":0.33675,"26.4":0.24622,"26.5":1.64934,"26.6":10.17665,"27.0":0.78031,"27.1":0,"27.2":0.01992},P:{"21":0.0091,"22":0.0182,"23":0.02731,"24":0.0091,"25":0.02731,"26":0.04551,"27":0.03641,"28":0.28218,"29":0.25487,"30":1.80229,_:"4 20 5.0-5.4 6.2-6.4 8.2 9.2 10.1 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0","7.2-7.4":0.03641,"11.1-11.2":0.0091},I:{"0":0.02608,"3":0,"4":0,"2.1":0,"2.2":0,"2.3":0,"4.1":0,"4.2-4.3":0,"4.4":0,"4.4.3-4.4.4":0.00001},K:{"0":0.2958,_:"10 11 12 11.1 11.5 12.1"},A:{"11":0.0039,_:"6 7 8 9 10 5.5"},S:{_:"2.5 3.0-3.1"},J:{_:"7 10"},N:{_:"10 11"},L:{"0":68.2335},R:{_:"0"},M:{"0":0.1044},Q:{"14.9":0.0087},O:{"0":0.6786},H:{all:0}};
.pnpm-store/v11/files/58/5b6b44f4ec36307842271adc49fca1245817a0c473b2ba314eb84bdbbc6e0a18fc7f2e0efa2078fd6fc70c4fb99ce73a65a8c545c84c7baf73bce0c7f9154b
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"rgba.mjs","sources":["../../../../../src/value/types/color/rgba.ts"],"sourcesContent":["import { clamp } from \"motion-utils\"\nimport { alpha as alphaType, number } from \"../numbers\"\nimport { RGBA } from \"../types\"\nimport { sanitize } from \"../utils/sanitize\"\nimport { isColorString, splitColor } from \"./utils\"\n\nconst clampRgbUnit = (v: number) => clamp(0, 255, v)\nexport const rgbUnit = {\n ...number,\n transform: (v: number) => Math.round(clampRgbUnit(v)),\n}\n\nexport const rgba = {\n test: /*@__PURE__*/ isColorString(\"rgb\", \"red\"),\n parse: /*@__PURE__*/ splitColor<RGBA>(\"red\", \"green\", \"blue\"),\n transform: ({ red, green, blue, alpha = 1 }: RGBA) =>\n \"rgba(\" +\n rgbUnit.transform(red) +\n \", \" +\n rgbUnit.transform(green) +\n \", \" +\n rgbUnit.transform(blue) +\n \", \" +\n sanitize(alphaType.transform(alpha)) +\n \")\",\n}\n"],"names":["alpha","alphaType"],"mappings":";;;;;AAMA,MAAM,YAAY,GAAG,CAAC,CAAS,KAAK,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;AAC7C,MAAM,OAAO,GAAG;AACnB,IAAA,GAAG,MAAM;AACT,IAAA,SAAS,EAAE,CAAC,CAAS,KAAK,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;;AAGlD,MAAM,IAAI,GAAG;IAChB,IAAI,gBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC;IAC/C,KAAK,gBAAgB,UAAU,CAAO,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC;AAC7D,IAAA,SAAS,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,SAAEA,OAAK,GAAG,CAAC,EAAQ,KAC7C,OAAO;AACP,QAAA,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC;QACtB,IAAI;AACJ,QAAA,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC;QACxB,IAAI;AACJ,QAAA,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC;QACvB,IAAI;AACJ,QAAA,QAAQ,CAACC,KAAS,CAAC,SAAS,CAACD,OAAK,CAAC,CAAC;QACpC,GAAG;;;;;"}
.pnpm-store/v11/files/58/5d59617a9c570f20dc8a6e2bd59bf9d2f106d8b5634cbffc59b370d9c5fac2326bbd5d844cb5eacc151ce3779641771c6b132ba8fea8605bfac38605d54e89
+24
View File
@@ -0,0 +1,24 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const CarTaxiFront = createLucideIcon("CarTaxiFront", [
["path", { d: "M10 2h4", key: "n1abiw" }],
[
"path",
{ d: "m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8", key: "1imjwt" }
],
["path", { d: "M7 14h.01", key: "1qa3f1" }],
["path", { d: "M17 14h.01", key: "7oqj8z" }],
["rect", { width: "18", height: "8", x: "3", y: "10", rx: "2", key: "a7itu8" }],
["path", { d: "M5 18v2", key: "ppbyun" }],
["path", { d: "M19 18v2", key: "gy7782" }]
]);
export { CarTaxiFront as default };
//# sourceMappingURL=car-taxi-front.js.map
.pnpm-store/v11/files/58/61f6badfe695c6111c8f383c9c16f915d39c5744fbb22010b78d461b9b3c41adf1ef1e6a95e798917eb7bb9206063add1164bfc52cc6a79ba9d9e6d1216e2a
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"size-rollup-motion-value.js","sources":["../../motion-utils/dist/es/global-config.mjs","../../motion-utils/dist/es/subscription-manager.mjs","../../motion-utils/dist/es/array.mjs","../lib/frameloop/order.js","../lib/frameloop/batcher.js","../lib/frameloop/render-step.js","../lib/frameloop/frame.js","../../motion-utils/dist/es/noop.mjs","../lib/frameloop/sync-time.js","../lib/value/index.js","../../motion-utils/dist/es/velocity-per-second.mjs"],"sourcesContent":["const MotionGlobalConfig = {};\n\nexport { MotionGlobalConfig };\n//# sourceMappingURL=global-config.mjs.map\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n constructor() {\n this.subscriptions = [];\n }\n add(handler) {\n addUniqueItem(this.subscriptions, handler);\n return () => removeItem(this.subscriptions, handler);\n }\n notify(a, b, c) {\n const numSubscriptions = this.subscriptions.length;\n if (!numSubscriptions)\n return;\n if (numSubscriptions === 1) {\n /**\n * If there's only a single handler we can just call it without invoking a loop.\n */\n this.subscriptions[0](a, b, c);\n }\n else {\n for (let i = 0; i < numSubscriptions; i++) {\n /**\n * Check whether the handler exists before firing as it's possible\n * the subscriptions were modified during this loop running.\n */\n const handler = this.subscriptions[i];\n handler && handler(a, b, c);\n }\n }\n }\n getSize() {\n return this.subscriptions.length;\n }\n clear() {\n this.subscriptions.length = 0;\n }\n}\n\nexport { SubscriptionManager };\n//# sourceMappingURL=subscription-manager.mjs.map\n","function addUniqueItem(arr, item) {\n if (arr.indexOf(item) === -1)\n arr.push(item);\n}\nfunction removeItem(arr, item) {\n const index = arr.indexOf(item);\n if (index > -1)\n arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n if (startIndex >= 0 && startIndex < arr.length) {\n const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n const [item] = arr.splice(fromIndex, 1);\n arr.splice(endIndex, 0, item);\n }\n return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n//# sourceMappingURL=array.mjs.map\n","export const stepsOrder = [\n \"setup\", // Compute\n \"read\", // Read\n \"resolveKeyframes\", // Write/Read/Write/Read\n \"preUpdate\", // Compute\n \"update\", // Compute\n \"preRender\", // Compute\n \"render\", // Write\n \"postRender\", // Compute\n];\n//# sourceMappingURL=order.js.map","import { MotionGlobalConfig } from \"motion-utils\";\nimport { stepsOrder } from \"./order\";\nimport { createRenderStep } from \"./render-step\";\nconst maxElapsed = 40;\nexport function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {\n let runNextFrame = false;\n let useDefaultElapsed = true;\n const state = {\n delta: 0.0,\n timestamp: 0.0,\n isProcessing: false,\n };\n const flagRunNextFrame = () => (runNextFrame = true);\n const steps = stepsOrder.reduce((acc, key) => {\n acc[key] = createRenderStep(flagRunNextFrame, allowKeepAlive ? key : undefined);\n return acc;\n }, {});\n const { setup, read, resolveKeyframes, preUpdate, update, preRender, render, postRender, } = steps;\n const processBatch = () => {\n const useManualTiming = MotionGlobalConfig.useManualTiming;\n const timestamp = useManualTiming\n ? state.timestamp\n : performance.now();\n runNextFrame = false;\n if (!useManualTiming) {\n state.delta = useDefaultElapsed\n ? 1000 / 60\n : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);\n }\n state.timestamp = timestamp;\n state.isProcessing = true;\n // Unrolled render loop for better per-frame performance\n setup.process(state);\n read.process(state);\n resolveKeyframes.process(state);\n preUpdate.process(state);\n update.process(state);\n preRender.process(state);\n render.process(state);\n postRender.process(state);\n state.isProcessing = false;\n if (runNextFrame && allowKeepAlive) {\n useDefaultElapsed = false;\n scheduleNextBatch(processBatch);\n }\n };\n const wake = () => {\n runNextFrame = true;\n useDefaultElapsed = true;\n if (!state.isProcessing) {\n scheduleNextBatch(processBatch);\n }\n };\n const schedule = stepsOrder.reduce((acc, key) => {\n const step = steLine truncated
.pnpm-store/v11/files/58/625731f99a06af476f33c07454c81d3ba2436eacca166dcf82a72b34bfa54de0f9d7398dc11e20e97b377913960f2966fd7180e15e26b069670b396f595907
+107
View File
@@ -0,0 +1,107 @@
'use strict'
const { webidl } = require('../../webidl')
const { validateCloseCodeAndReason } = require('../util')
const { kConstruct } = require('../../../core/symbols')
const { kEnumerableProperty } = require('../../../core/util')
function createInheritableDOMException () {
// https://github.com/nodejs/node/issues/59677
class Test extends DOMException {
get reason () {
return ''
}
}
if (new Test().reason !== undefined) {
return DOMException
}
return new Proxy(DOMException, {
construct (target, args, newTarget) {
const instance = Reflect.construct(target, args, target)
Object.setPrototypeOf(instance, newTarget.prototype)
return instance
}
})
}
let createUnvalidatedWebSocketError
class WebSocketError extends createInheritableDOMException() {
#closeCode
#reason
constructor (message = '', init = undefined) {
message = webidl.converters.DOMString(message, 'WebSocketError', 'message')
// 1. Set this 's name to " WebSocketError ".
// 2. Set this 's message to message .
super(message, 'WebSocketError')
if (init === kConstruct) {
return
} else if (init !== null) {
init = webidl.converters.WebSocketCloseInfo(init)
}
// 3. Let code be init [" closeCode "] if it exists , or null otherwise.
let code = init.closeCode ?? null
// 4. Let reason be init [" reason "] if it exists , or the empty string otherwise.
const reason = init.reason ?? ''
// 5. Validate close code and reason with code and reason .
validateCloseCodeAndReason(code, reason)
// 6. If reason is non-empty, but code is not set, then set code to 1000 ("Normal Closure").
if (reason.length !== 0 && code === null) {
code = 1000
}
// 7. Set this 's closeCode to code .
this.#closeCode = code
// 8. Set this 's reason to reason .
this.#reason = reason
}
get closeCode () {
return this.#closeCode
}
get reason () {
return this.#reason
}
/**
* @param {string} message
* @param {number|null} code
* @param {string} reason
*/
static {
createUnvalidatedWebSocketError = (message, code, reason) => {
const error = new WebSocketError(message, kConstruct)
error.#closeCode = code
error.#reason = reason
return error
}
webidl.is.WebSocketError = (arg) => {
return arg != null && typeof arg === 'object' && #reason in arg
}
}
}
Object.defineProperties(WebSocketError.prototype, {
closeCode: kEnumerableProperty,
reason: kEnumerableProperty,
[Symbol.toStringTag]: {
value: 'WebSocketError',
writable: false,
enumerable: false,
configurable: true
}
})
module.exports = { WebSocketError, createUnvalidatedWebSocketError }
.pnpm-store/v11/files/58/627fd099ae00abc314b8af2c875a3ec1def4add15ebfc336387f14fbacd371b8286827245dc41707105d6a522cd5e1cb5711c32288e87718fca0e058dadeb3
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"badge-japanese-yen.js","sources":["../../../src/icons/badge-japanese-yen.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name BadgeJapaneseYen\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMy44NSA4LjYyYTQgNCAwIDAgMSA0Ljc4LTQuNzcgNCA0IDAgMCAxIDYuNzQgMCA0IDQgMCAwIDEgNC43OCA0Ljc4IDQgNCAwIDAgMSAwIDYuNzQgNCA0IDAgMCAxLTQuNzcgNC43OCA0IDQgMCAwIDEtNi43NSAwIDQgNCAwIDAgMS00Ljc4LTQuNzcgNCA0IDAgMCAxIDAtNi43NloiIC8+CiAgPHBhdGggZD0ibTkgOCAzIDN2NyIgLz4KICA8cGF0aCBkPSJtMTIgMTEgMy0zIiAvPgogIDxwYXRoIGQ9Ik05IDEyaDYiIC8+CiAgPHBhdGggZD0iTTkgMTZoNiIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/badge-japanese-yen\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst BadgeJapaneseYen = createLucideIcon('BadgeJapaneseYen', [\n [\n 'path',\n {\n d: 'M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z',\n key: '3c2336',\n },\n ],\n ['path', { d: 'm9 8 3 3v7', key: '17yadx' }],\n ['path', { d: 'm12 11 3-3', key: 'p4cfq1' }],\n ['path', { d: 'M9 12h6', key: '1c52cq' }],\n ['path', { d: 'M9 16h6', key: '8wimt3' }],\n]);\n\nexport default BadgeJapaneseYen;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAmB,iBAAiB,kBAAoB,CAAA,CAAA,CAAA;AAAA,CAC5D,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CAAA,CACA,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAc,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC3C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAc,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC3C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACxC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC1C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/64c48b5b811199a005ea220f0fc4ea6b15bfccc4c95a17ad6f2bfde5b2fcd18208f55a2dc043645d86df59dacacb9f17bc87af8c7245a2828b1fe337d34365
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"cloud-fog.js","sources":["../../../src/icons/cloud-fog.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name CloudFog\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNNCAxNC44OTlBNyA3IDAgMSAxIDE1LjcxIDhoMS43OWE0LjUgNC41IDAgMCAxIDIuNSA4LjI0MiIgLz4KICA8cGF0aCBkPSJNMTYgMTdINyIgLz4KICA8cGF0aCBkPSJNMTcgMjFIOSIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/cloud-fog\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst CloudFog = createLucideIcon('CloudFog', [\n ['path', { d: 'M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242', key: '1pljnt' }],\n ['path', { d: 'M16 17H7', key: 'pygtm1' }],\n ['path', { d: 'M17 21H9', key: '1u2q02' }],\n]);\n\nexport default CloudFog;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAW,iBAAiB,UAAY,CAAA,CAAA,CAAA;AAAA,CAAA,CAC5C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA4D,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACzF,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAY,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACzC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAY,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC3C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/652f4f9e3a082a0471b2705472e126ab8249f1805f78c6966625aeac306ed187323b0c4cc145eafb39f6f9d0465aa8c2abbe13f273ab2a722e03901994bb78
+14
View File
@@ -0,0 +1,14 @@
'use strict'
const u = require('universalify').fromPromise
const { makeDir: _makeDir, makeDirSync } = require('./make-dir')
const makeDir = u(_makeDir)
module.exports = {
mkdirs: makeDir,
mkdirsSync: makeDirSync,
// alias
mkdirp: makeDir,
mkdirpSync: makeDirSync,
ensureDir: makeDir,
ensureDirSync: makeDirSync
}
.pnpm-store/v11/files/58/77f097e8b2067b12edeca89e97c84452eccdb0c64e1780f8b375dec87ce53aa0152aa879c3a70231cdcba8ee337b0ab9a5d815a1d0c015074ae9308a37cecd
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"candy-cane.js","sources":["../../../src/icons/candy-cane.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name CandyCane\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNNS43IDIxYTIgMiAwIDAgMS0zLjUtMmw4LjYtMTRhNiA2IDAgMCAxIDEwLjQgNiAyIDIgMCAxIDEtMy40NjQtMiAyIDIgMCAxIDAtMy40NjQtMloiIC8+CiAgPHBhdGggZD0iTTE3Ljc1IDcgMTUgMi4xIiAvPgogIDxwYXRoIGQ9Ik0xMC45IDQuOCAxMyA5IiAvPgogIDxwYXRoIGQ9Im03LjkgOS43IDIgNC40IiAvPgogIDxwYXRoIGQ9Ik00LjkgMTQuNyA3IDE4LjkiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/candy-cane\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst CandyCane = createLucideIcon('CandyCane', [\n [\n 'path',\n {\n d: 'M5.7 21a2 2 0 0 1-3.5-2l8.6-14a6 6 0 0 1 10.4 6 2 2 0 1 1-3.464-2 2 2 0 1 0-3.464-2Z',\n key: 'isaq8g',\n },\n ],\n ['path', { d: 'M17.75 7 15 2.1', key: '12x7e8' }],\n ['path', { d: 'M10.9 4.8 13 9', key: '100a87' }],\n ['path', { d: 'm7.9 9.7 2 4.4', key: 'ntfhaj' }],\n ['path', { d: 'M4.9 14.7 7 18.9', key: '1x43jy' }],\n]);\n\nexport default CandyCane;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAY,iBAAiB,WAAa,CAAA,CAAA,CAAA;AAAA,CAC9C,CAAA,CAAA;AAAA,CAAA,CAAA,CAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACA,CAAA,CAAA,CAAA,CAAA;AAAA,CACE,CAAA,CAAA,CAAA,CAAA,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACH,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAAA,CACP,CAAA,CAAA,CAAA,CAAA;AAAA,CACF,CAAA,CAAA,CAAA;AAAA,CAAA,CACA,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAmB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAChD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAkB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC/C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAkB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC/C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAoB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AACnD,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/7833bcf009b2ed4d07ea6c9711fcd5e1c3e546c29552cca41bec0f36ca5c87eac84e1a7c31b1d1c428cb3aa4c7bf6ec4d7a83eaf8cd499df1c0dd12380daeb
+7
View File
@@ -0,0 +1,7 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isArray = isArray;
// https://github.com/microsoft/TypeScript/issues/17002
function isArray(arg) {
return Array.isArray(arg);
}
.pnpm-store/v11/files/58/7cf0a47ffad6dba672124f2d0344f46db83a1d32546e517682ab20edea8d3686a62835160d81d332ba7144b3e1fa9a284d2e3f677b3978fd58f133b4d9059e
+28
View File
@@ -0,0 +1,28 @@
# @zxcvbn-ts/language-common
The common dictionary and language package for zxcvbn-ts
## Install
#### npm:
`npm install @zxcvbn-ts/language-common --save`
#### yarn:
`yarn add @zxcvbn-ts/language-common`
## Setup
```js
import { ZxcvbnFactory } from '@zxcvbn-ts/core'
import * as zxcvbnCommonPackage from '@zxcvbn-ts/language-common'
const password = 'somePassword'
const options = {
...zxcvbnCommonPackage,
}
const zxcvbn = new ZxcvbnFactory(options)
zxcvbn.check(password)
```
.pnpm-store/v11/files/58/7d8f153c560a18bb3220152a81e1071eebd48a8e02d31475779381aceb59fe267fceb9b27572c4e1175d85bf0b0f00b051d278340127d6779903c7f40bddee
+5
View File
@@ -0,0 +1,5 @@
const appearAnimationStore = new Map();
const appearComplete = new Map();
export { appearAnimationStore, appearComplete };
//# sourceMappingURL=store.mjs.map
.pnpm-store/v11/files/58/814909f63e6fb9fe982bafcf59f3110dff88d83f6e5ad09d5ebd6c0ceb2882cf61119a574b1acafe2a00e2e1aeaeebc068114470ba2e2058a9614dbd6fa5ca
+26
View File
@@ -0,0 +1,26 @@
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABILITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/// <reference lib="es5" />
/// <reference lib="es2015.core" />
/// <reference lib="es2015.collection" />
/// <reference lib="es2015.iterable" />
/// <reference lib="es2015.generator" />
/// <reference lib="es2015.promise" />
/// <reference lib="es2015.proxy" />
/// <reference lib="es2015.reflect" />
/// <reference lib="es2015.symbol" />
/// <reference lib="es2015.symbol.wellknown" />
.pnpm-store/v11/files/58/8c92c47e37168db2bda1c66037e0d94ff4e80488a35fd1fab39f143c6926c92068e17b66a77073c28a4ae5c6276559365de3129ed1eed5a52d01fd0f872551
+82
View File
@@ -0,0 +1,82 @@
import type {
CodeKeywordDefinition,
ErrorObject,
KeywordErrorDefinition,
AnySchema,
} from "../../types"
import type {KeywordCxt} from "../../compile/validate"
import {_, Name} from "../../compile/codegen"
import {alwaysValidSchema} from "../../compile/util"
import {SchemaCxt} from "../../compile"
export type OneOfError = ErrorObject<
"oneOf",
{passingSchemas: [number, number] | null},
AnySchema[]
>
const error: KeywordErrorDefinition = {
message: "must match exactly one schema in oneOf",
params: ({params}) => _`{passingSchemas: ${params.passing}}`,
}
const def: CodeKeywordDefinition = {
keyword: "oneOf",
schemaType: "array",
trackErrors: true,
error,
code(cxt: KeywordCxt) {
const {gen, schema, parentSchema, it} = cxt
/* istanbul ignore if */
if (!Array.isArray(schema)) throw new Error("ajv implementation error")
if (it.opts.discriminator && parentSchema.discriminator) return
const schArr: AnySchema[] = schema
const valid = gen.let("valid", false)
const passing = gen.let("passing", null)
const schValid = gen.name("_valid")
cxt.setParams({passing})
// TODO possibly fail straight away (with warning or exception) if there are two empty always valid schemas
gen.block(validateOneOf)
cxt.result(
valid,
() => cxt.reset(),
() => cxt.error(true)
)
function validateOneOf(): void {
schArr.forEach((sch: AnySchema, i: number) => {
let schCxt: SchemaCxt | undefined
if (alwaysValidSchema(it, sch)) {
gen.var(schValid, true)
} else {
schCxt = cxt.subschema(
{
keyword: "oneOf",
schemaProp: i,
compositeRule: true,
},
schValid
)
}
if (i > 0) {
gen
.if(_`${schValid} && ${valid}`)
.assign(valid, false)
.assign(passing, _`[${passing}, ${i}]`)
.else()
}
gen.if(schValid, () => {
gen.assign(valid, true)
gen.assign(passing, i)
if (schCxt) cxt.mergeEvaluated(schCxt, Name)
})
})
}
},
}
export default def
.pnpm-store/v11/files/58/92e0c7f0bb8deece9e255df7296e059b5fa42766debbd1b7b869db5eb0451567a66682429dbd402fd58fd6b98d562a760ea95b0621c46473d829b073a7fd48
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"move-diagonal.js","sources":["../../../src/icons/move-diagonal.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name MoveDiagonal\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTEgMTlINXYtNiIgLz4KICA8cGF0aCBkPSJNMTMgNWg2djYiIC8+CiAgPHBhdGggZD0iTTE5IDUgNSAxOSIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/move-diagonal\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst MoveDiagonal = createLucideIcon('MoveDiagonal', [\n ['path', { d: 'M11 19H5v-6', key: '8awifj' }],\n ['path', { d: 'M13 5h6v6', key: '7voy1q' }],\n ['path', { d: 'M19 5 5 19', key: 'wwaj1z' }],\n]);\n\nexport default MoveDiagonal;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAe,iBAAiB,cAAgB,CAAA,CAAA,CAAA;AAAA,CAAA,CACpD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAe,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC5C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAa,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC1C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAc,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC7C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/92f7ff7d637f40ac508b43a21efbbf252d660dce43975d6d97b3edcb66ca68e4ae6131ceaf4f2213a4bf3c6992a8baeb861df4792620a5d792fabd12643055
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"time-conversion.mjs","sources":["../../src/time-conversion.ts"],"sourcesContent":["/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\n\n/*#__NO_SIDE_EFFECTS__*/\nexport const secondsToMilliseconds = (seconds: number) => seconds * 1000\n\n/*#__NO_SIDE_EFFECTS__*/\nexport const millisecondsToSeconds = (milliseconds: number) =>\n milliseconds / 1000\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AAEH;AACO,MAAM,qBAAqB,GAAG,CAAC,OAAe,KAAK,OAAO,GAAG;AAEpE;AACO,MAAM,qBAAqB,GAAG,CAAC,YAAoB,KACtD,YAAY,GAAG;;;;"}
.pnpm-store/v11/files/58/991d9dcc472f56d93bf69b65ef6c5d0b1f4ad0a094a812411e75d32adbe9a54ffb3739ddeb71dced591bf2be220740bc17aff7e9087069c0dce94a99b3468f
+94
View File
@@ -0,0 +1,94 @@
# content-type
[![NPM Version][npm-version-image]][npm-url]
[![NPM Downloads][npm-downloads-image]][npm-url]
[![Node.js Version][node-image]][node-url]
[![Build Status][ci-image]][ci-url]
[![Coverage Status][coveralls-image]][coveralls-url]
Create and parse HTTP Content-Type header according to RFC 7231
## Installation
```sh
$ npm install content-type
```
## API
```js
var contentType = require('content-type')
```
### contentType.parse(string)
```js
var obj = contentType.parse('image/svg+xml; charset=utf-8')
```
Parse a `Content-Type` header. This will return an object with the following
properties (examples are shown for the string `'image/svg+xml; charset=utf-8'`):
- `type`: The media type (the type and subtype, always lower case).
Example: `'image/svg+xml'`
- `parameters`: An object of the parameters in the media type (name of parameter
always lower case). Example: `{charset: 'utf-8'}`
Throws a `TypeError` if the string is missing or invalid.
### contentType.parse(req)
```js
var obj = contentType.parse(req)
```
Parse the `Content-Type` header from the given `req`. Short-cut for
`contentType.parse(req.headers['content-type'])`.
Throws a `TypeError` if the `Content-Type` header is missing or invalid.
### contentType.parse(res)
```js
var obj = contentType.parse(res)
```
Parse the `Content-Type` header set on the given `res`. Short-cut for
`contentType.parse(res.getHeader('content-type'))`.
Throws a `TypeError` if the `Content-Type` header is missing or invalid.
### contentType.format(obj)
```js
var str = contentType.format({
type: 'image/svg+xml',
parameters: { charset: 'utf-8' }
})
```
Format an object into a `Content-Type` header. This will return a string of the
content type for the given object with the following properties (examples are
shown that produce the string `'image/svg+xml; charset=utf-8'`):
- `type`: The media type (will be lower-cased). Example: `'image/svg+xml'`
- `parameters`: An object of the parameters in the media type (name of the
parameter will be lower-cased). Example: `{charset: 'utf-8'}`
Throws a `TypeError` if the object contains an invalid type or parameter names.
## License
[MIT](LICENSE)
[ci-image]: https://badgen.net/github/checks/jshttp/content-type/master?label=ci
[ci-url]: https://github.com/jshttp/content-type/actions/workflows/ci.yml
[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/content-type/master
[coveralls-url]: https://coveralls.io/r/jshttp/content-type?branch=master
[node-image]: https://badgen.net/npm/node/content-type
[node-url]: https://nodejs.org/en/download
[npm-downloads-image]: https://badgen.net/npm/dm/content-type
[npm-url]: https://npmjs.org/package/content-type
[npm-version-image]: https://badgen.net/npm/v/content-type
.pnpm-store/v11/files/58/9d04cdf875a027f699af78b103a5bf811a1d6a1ce21e90ba88cea8e0293388073cde3a2d86fcaa5636fb6b6ff982ef03eb4ae2d708459bb399118662a9f45f
+189
View File
@@ -0,0 +1,189 @@
import { stripVTControlCharacters } from 'node:util';
import { slash } from '@vitest/utils/helpers';
import { isAbsolute, relative, dirname, basename } from 'pathe';
import c from 'tinyrainbow';
const F_RIGHT = "→";
const F_DOWN = "↓";
const F_DOWN_RIGHT = "↳";
const F_POINTER = "❯";
const F_DOT = "·";
const F_CHECK = "✓";
const F_CROSS = "×";
const F_LONG_DASH = "⎯";
const F_TODO = "□";
const F_TREE_NODE_MIDDLE = "├──";
const F_TREE_NODE_END = "└──";
const pointer = c.yellow(F_POINTER);
const skipped = c.dim(c.gray(F_DOWN));
const todo = c.dim(c.gray(F_TODO));
const benchmarkPass = c.green(F_DOT);
const testPass = c.green(F_CHECK);
const taskFail = c.red(F_CROSS);
const suiteFail = c.red(F_POINTER);
const pending = c.gray("·");
const separator = c.dim(" > ");
const labelDefaultColors = [
c.bgYellow,
c.bgCyan,
c.bgGreen,
c.bgMagenta
];
function getCols(delta = 0) {
let length = process.stdout?.columns;
if (!length || Number.isNaN(length)) length = 30;
return Math.max(length + delta, 0);
}
function errorBanner(message) {
return divider(c.bold(c.bgRed(` ${message} `)), null, null, c.red);
}
function divider(text, left, right, color) {
const cols = getCols();
const c = color || ((text) => text);
if (text) {
const textLength = stripVTControlCharacters(text).length;
if (left == null && right != null) left = cols - textLength - right;
else {
left = left ?? Math.floor((cols - textLength) / 2);
right = cols - textLength - left;
}
left = Math.max(0, left);
right = Math.max(0, right);
return `${c(F_LONG_DASH.repeat(left))}${text}${c(F_LONG_DASH.repeat(right))}`;
}
return F_LONG_DASH.repeat(cols);
}
function formatTestPath(root, path) {
if (isAbsolute(path)) path = relative(root, path);
const dir = dirname(path);
const ext = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)?.[0] || "";
const base = basename(path, ext);
return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
}
function renderSnapshotSummary(rootDir, snapshots) {
const summary = [];
if (snapshots.added) summary.push(c.bold(c.green(`${snapshots.added} written`)));
if (snapshots.unmatched) summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
if (snapshots.updated) summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
if (snapshots.filesRemoved) if (snapshots.didUpdate) summary.push(c.bold(c.green(`${snapshots.filesRemoved} files removed `)));
else summary.push(c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `)));
if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
const [head, ...tail] = snapshots.filesRemovedList;
summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`);
tail.forEach((key) => {
summary.push(` ${c.gray(F_DOT)} ${formatTestPath(rootDir, key)}`);
});
}
if (snapshots.unchecked) {
if (snapshots.didUpdate) summary.push(c.bold(c.green(`${snapshots.unchecked} removed`)));
else summary.push(c.bold(c.yellow(`${snapshots.unchecked} obsolete`)));
snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, uncheckedFile.filePath)}`);
uncheckedFile.keys.forEach((key) => summary.push(` ${c.gray(F_DOT)} ${key}`));
});
}
return summary;
}
function countTestErrors(tasks) {
return tasks.reduce((c, i) => c + (i.result?.errors?.length || 0), 0);
}
function getStateString(tasks, name = "tests", showTotal = true) {
if (tasks.length === 0) return c.dim(`no ${name}`);
const passed = tasks.reduce((acc, i) => {
// Exclude expected failures from passed count
if (i.result?.state === "pass" && i.type === "test" && i.fails) return acc;
return i.result?.state === "pass" ? acc + 1 : acc;
}, 0);
const failed = tasks.reduce((acc, i) => i.result?.state === "fail" ? acc + 1 : acc, 0);
const skipped = tasks.reduce((acc, i) => i.mode === "skip" ? acc + 1 : acc, 0);
const todo = tasks.reduce((acc, i) => i.mode === "todo" ? acc + 1 : acc, 0);
const expectedFail = tasks.reduce((acc, i) => {
// Count tests that are marked as .fails and passed (which means they failed as expected)
if (i.result?.state === "pass" && i.type === "test" && i.fails) return acc + 1;
return acc;
}, 0);
return [
failed ? c.bold(c.red(`${failed} failed`)) : null,
passed ? c.bold(c.green(`${passed} passed`)) : null,
expectedFail ? c.cyan(`${expectedFail} expected fail`) : null,
skipped ? c.yellow(`${skipped} skipped`) : null,
todo ? c.gray(`${todo} todo`) : null
].filter(Boolean).join(c.dim(" | ")) + (showTotal ? c.gray(` (${tasks.length})`) : "");
}
function getStateSymbol(task) {
if (task.mode === "todo") return todo;
if (task.mode === "skip") return skipped;
if (!task.result) return pending;
if (task.result.state === "run" || task.result.state === "queued") {
if (task.type === "suite") return pointer;
}
if (task.result.state === "pass") return task.meta?.benchmark ? benchmarkPass : testPass;
if (task.result.state === "fail") return task.type === "suite" ? suiteFail : taskFail;
return " ";
}
function formatTimeString(date) {
return date.toTimeString().split(" ")[0];
}
function formatTime(time) {
if (time > 1e3) return `${(time / 1e3).toFixed(2)}s`;
return `${Math.round(time)}ms`;
}
function formatProjectName(project, suffix = " ") {
if (!project?.name) return "";
if (!c.isColorSupported) return `|${project.name}|${suffix}`;
let background = project.color && c[`bg${capitalize(project.color)}`];
if (!background) background = labelDefaultColors[project.name.split("").reduce((acc, v, idx) => acc + v.charCodeAt(0) + idx, 0) % labelDefaultColors.length];
return c.black(background(` ${project.name} `)) + suffix;
}
function withLabel(color, label, message) {
const bgColor = `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
return `${c.bold(c.black(c[bgColor](` ${label} `)))} ${message ? c[color](message) : ""}`;
}
function padSummaryTitle(str) {
return c.dim(`${str.padStart(11)} `);
}
function truncateString(text, maxLength) {
const plainText = stripVTControlCharacters(text);
if (plainText.length <= maxLength) return text;
return `${plainText.slice(0, maxLength - 1)}…`;
}
function capitalize(text) {
return `${text[0].toUpperCase()}${text.slice(1)}`;
}
/**
* Returns the singular or plural form of a word based on the count.
*/
function noun(count, singular, plural) {
if (count === 1) return singular;
return plural;
}
var utils = /*#__PURE__*/Object.freeze({
__proto__: null,
benchmarkPass: benchmarkPass,
countTestErrors: countTestErrors,
divider: divider,
errorBanner: errorBanner,
formatProjectName: formatProjectName,
formatTestPath: formatTestPath,
formatTime: formatTime,
formatTimeString: formatTimeString,
getStateString: getStateString,
getStateSymbol: getStateSymbol,
noun: noun,
padSummaryTitle: padSummaryTitle,
pending: pending,
pointer: pointer,
renderSnapshotSummary: renderSnapshotSummary,
separator: separator,
skipped: skipped,
suiteFail: suiteFail,
taskFail: taskFail,
testPass: testPass,
todo: todo,
truncateString: truncateString,
withLabel: withLabel
});
export { F_POINTER as F, taskFail as a, F_CHECK as b, F_DOWN_RIGHT as c, divider as d, errorBanner as e, formatTimeString as f, formatProjectName as g, getStateSymbol as h, getStateString as i, formatTime as j, countTestErrors as k, F_TREE_NODE_END as l, F_TREE_NODE_MIDDLE as m, noun as n, F_RIGHT as o, padSummaryTitle as p, renderSnapshotSummary as r, separator as s, truncateString as t, utils as u, withLabel as w };
.pnpm-store/v11/files/58/a05263d4b2c21c19a98576c74029600eaba03835d6be8685d956096019a450f9cc276023dec229db111f767f56130f54640892f7b4406a072de8b0d79306c7
+30
View File
@@ -0,0 +1,30 @@
import { encoder, decoder } from '../lib/buffer_utils.js';
import { encodeBase64, decodeBase64 } from '../lib/base64.js';
export function decode(input) {
if (Uint8Array.fromBase64) {
return Uint8Array.fromBase64(typeof input === 'string' ? input : decoder.decode(input), {
alphabet: 'base64url',
});
}
let encoded = input;
if (encoded instanceof Uint8Array) {
encoded = decoder.decode(encoded);
}
encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
try {
return decodeBase64(encoded);
}
catch {
throw new TypeError('The input to be decoded is not correctly encoded.');
}
}
export function encode(input) {
let unencoded = input;
if (typeof unencoded === 'string') {
unencoded = encoder.encode(unencoded);
}
if (Uint8Array.prototype.toBase64) {
return unencoded.toBase64({ alphabet: 'base64url', omitPadding: true });
}
return encodeBase64(unencoded).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
}
.pnpm-store/v11/files/58/a074431bc3a9c68f2ce9b4d930dd9a80dcf75e58f466cd2bd3241395dac9055665ca8eac5ddb6e2a993a14279430761dfdfa67370d8c195765e7bcb0123408
+20
View File
@@ -0,0 +1,20 @@
function returnValue(value) {
return value;
}
function formatMessage(message, callback = returnValue) {
return message.reduce((prev, curr, index) => {
let msg;
if (curr instanceof Error) {
msg = curr.stack || curr.message;
} else if (typeof curr === "object") {
msg = JSON.stringify(curr);
} else {
msg = String(curr);
}
msg = callback(msg);
return index === 0 ? msg : `${prev} ${msg}`;
}, "");
}
export {
formatMessage as default
};
.pnpm-store/v11/files/58/a0e646fc08dc1749c38643632e80fa96b1a6a125cd97a6beb2b08f83070b530f839ee196b6a9b05c7a71219309dc31a636c8c0c00b6b81256b66b52f73996e
+34
View File
@@ -0,0 +1,34 @@
'use strict';
var test = require('tape');
var getDunderProto = require('../get');
test('getDunderProto', { skip: !getDunderProto }, function (t) {
if (!getDunderProto) {
throw 'should never happen; this is just for type narrowing'; // eslint-disable-line no-throw-literal
}
// @ts-expect-error
t['throws'](function () { getDunderProto(); }, TypeError, 'throws if no argument');
// @ts-expect-error
t['throws'](function () { getDunderProto(undefined); }, TypeError, 'throws with undefined');
// @ts-expect-error
t['throws'](function () { getDunderProto(null); }, TypeError, 'throws with null');
t.equal(getDunderProto({}), Object.prototype);
t.equal(getDunderProto([]), Array.prototype);
t.equal(getDunderProto(function () {}), Function.prototype);
t.equal(getDunderProto(/./g), RegExp.prototype);
t.equal(getDunderProto(42), Number.prototype);
t.equal(getDunderProto(true), Boolean.prototype);
t.equal(getDunderProto('foo'), String.prototype);
t.end();
});
test('no dunder proto', { skip: !!getDunderProto }, function (t) {
t.notOk('__proto__' in Object.prototype, 'no __proto__ in Object.prototype');
t.end();
});
.pnpm-store/v11/files/58/a128c36bcd8c92f5350025e1c2d2dadcc7ace674c904cdc11de109449e7ab883f3b7596722ddf57fe1148a361a866180bbec3de1ec81f83b6f747639e6fd10
+39
View File
@@ -0,0 +1,39 @@
{
"name": "path-exists",
"version": "4.0.0",
"description": "Check if a path exists",
"license": "MIT",
"repository": "sindresorhus/path-exists",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"engines": {
"node": ">=8"
},
"scripts": {
"test": "xo && ava && tsd"
},
"files": [
"index.js",
"index.d.ts"
],
"keywords": [
"path",
"exists",
"exist",
"file",
"filepath",
"fs",
"filesystem",
"file-system",
"access",
"stat"
],
"devDependencies": {
"ava": "^1.4.1",
"tsd": "^0.7.2",
"xo": "^0.24.0"
}
}
.pnpm-store/v11/files/58/a15709fd719141d0cf4a756826313b0957b72cad557815ad60861fb8b7b0c12912132b4e54b5d5105ba202680ef9ddfbe7a18d83a51b940aceb32b711c4e4c
+57
View File
@@ -0,0 +1,57 @@
// Copyright 2012 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
function FormatStackTrace(error, frames) {
var lines = [];
try {
lines.push(error.toString());
} catch (e) {
try {
lines.push("<error: " + e + ">");
} catch (ee) {
lines.push("<error>");
}
}
for (var i = 0; i < frames.length; i++) {
var frame = frames[i];
var line;
try {
line = frame.toString();
} catch (e) {
try {
line = "<error: " + e + ">";
} catch (ee) {
// Any code that reaches this point is seriously nasty!
line = "<error>";
}
}
lines.push(" at " + line);
}
return lines.join("\n");
}
module.exports = FormatStackTrace;
.pnpm-store/v11/files/58/a5a61bd8cfcac2f36f585f94cb6933f85acfb3d0bc6227d8a23c4308c737edf32c0d47c5c286e9795e3e502c688469610e1c792742d8be14bcbf1ee6d1df41
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"circle-slash.js","sources":["../../../src/icons/circle-slash.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name CircleSlash\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIgLz4KICA8bGluZSB4MT0iOSIgeDI9IjE1IiB5MT0iMTUiIHkyPSI5IiAvPgo8L3N2Zz4K) - https://lucide.dev/icons/circle-slash\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst CircleSlash = createLucideIcon('CircleSlash', [\n ['circle', { cx: '12', cy: '12', r: '10', key: '1mglay' }],\n ['line', { x1: '9', x2: '15', y1: '15', y2: '9', key: '1dfufj' }],\n]);\n\nexport default CircleSlash;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAc,iBAAiB,aAAe,CAAA,CAAA,CAAA;AAAA,CAClD,CAAA,CAAC,QAAU,CAAA,CAAA,CAAA,CAAE,EAAI,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAM,CAAI,CAAA,CAAA,CAAA,IAAA,CAAM,CAAA,CAAG,EAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAM,GAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAAU,CAAA,CAAA;AAAA,CACzD,CAAA,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAE,CAAA,CAAA,CAAA,EAAI,CAAK,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAI,CAAM,CAAA,CAAA,CAAA,CAAA,CAAA,EAAA,CAAI,CAAA,CAAA,CAAA,CAAA,CAAM,CAAA,CAAA,CAAA,CAAA,CAAI,CAAA,CAAA,CAAA,CAAK,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAClE,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/a6c33206b590739506bf327f5bed6dacd78ebc2f4c81b677e0749726b643880673dd131718f0f72d5eaa93dc07eb763c9587bd2ea4badffca9fc9a9688680f
+18
View File
@@ -0,0 +1,18 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const CircleEllipsis = createLucideIcon("CircleEllipsis", [
["circle", { cx: "12", cy: "12", r: "10", key: "1mglay" }],
["path", { d: "M17 12h.01", key: "1m0b6t" }],
["path", { d: "M12 12h.01", key: "1mp3jc" }],
["path", { d: "M7 12h.01", key: "eqddd0" }]
]);
export { CircleEllipsis as default };
//# sourceMappingURL=circle-ellipsis.js.map
.pnpm-store/v11/files/58/b1692d236efe685be86c0bb6ddb7c06b9bf9b8e5937a9375232425c5f07472e7818fc213b8bc0608ea11bf18e44558c1484716fdd0401a1323a57138cdac92
+11
View File
@@ -0,0 +1,11 @@
{
"root": true,
"extends": "@ljharb",
"rules": {
"max-lines-per-function": 0,
"multiline-comment-style": 1,
"new-cap": [2, { "capIsNewExceptions": ["GetIntrinsic"] }],
},
}
.pnpm-store/v11/files/58/b94ea1841f0ae90386bcbafc516c5503d6b1e4ae812a082cb6b278686a42b5939214b96f48fedc1cfa628a1c8e2abb40e0dbd3e5b66b58cc2830527d3108d9
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"use-motion-ref.mjs","sources":["../../../../src/motion/utils/use-motion-ref.ts"],"sourcesContent":["\"use client\"\n\nimport type { VisualElement } from \"motion-dom\"\nimport * as React from \"react\"\nimport { useCallback, useInsertionEffect, useRef } from \"react\"\nimport { VisualState } from \"./use-visual-state\"\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nexport function useMotionRef<Instance, RenderState>(\n visualState: VisualState<Instance, RenderState>,\n visualElement?: VisualElement<Instance> | null,\n externalRef?: React.Ref<Instance>\n): React.Ref<Instance> {\n /**\n * Store externalRef in a ref to avoid including it in the useCallback\n * dependency array. Including externalRef in dependencies causes issues\n * with libraries like Radix UI that create new callback refs on each render\n * when using asChild - this would cause the callback to be recreated,\n * triggering element remounts and breaking AnimatePresence exit animations.\n */\n const externalRefContainer = useRef(externalRef)\n useInsertionEffect(() => {\n externalRefContainer.current = externalRef\n })\n\n // Store cleanup function returned by callback refs (React 19 feature)\n const refCleanup = useRef<(() => void) | null>(null)\n\n return useCallback(\n (instance: Instance) => {\n if (instance) {\n visualState.onMount?.(instance)\n }\n\n const ref = externalRefContainer.current\n if (typeof ref === \"function\") {\n if (instance) {\n const cleanup = ref(instance)\n if (typeof cleanup === \"function\") {\n refCleanup.current = cleanup\n }\n } else if (refCleanup.current) {\n refCleanup.current()\n refCleanup.current = null\n } else {\n ref(instance)\n }\n } else if (ref) {\n ;(ref as React.MutableRefObject<Instance>).current = instance\n }\n\n if (visualElement) {\n instance ? visualElement.mount(instance) : visualElement.unmount()\n }\n },\n [visualElement]\n )\n}\n"],"names":[],"mappings":";;;AAOA;;;AAGG;;AAMC;;;;;;AAMG;AACH;;AAEI;AACJ;;AAGA;AAEA;;AAGY;;AAGJ;AACA;;AAEQ;AACA;AACI;;;AAED;;AAEH;;;;;;;AAKF;;;AAIF;;AAER;AAGR;;"}
.pnpm-store/v11/files/58/badfe1bec9f4ce6ff79c37466a3c02d74e26345a0cb90b0d90f6a2517d237a3d4da4955ac519c0333f6207add340e3340cb7e5ab67f850c7fb4ff02d3c0a72
+8
View File
@@ -0,0 +1,8 @@
import { createJiti } from "./types.js";
export * from "./types.js";
/**
* @deprecated Please use `import { createJiti } from "jiti"`
*/
export default createJiti;
.pnpm-store/v11/files/58/be12e49ebbf285ed8f822b4eb140442c979a966d9fc53f06beaa692ff15881718d29a7bd0790d7d0e1f33a5123ce51b193aa9fd76f734c7a31e911e1eca023
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"style-computed.mjs","sources":["../../../../src/render/dom/style-computed.ts"],"sourcesContent":["import { isCSSVar } from \"./is-css-var\"\n\nexport function getComputedStyle(\n element: HTMLElement | SVGElement,\n name: string\n) {\n const computedStyle = window.getComputedStyle(element)\n return isCSSVar(name)\n ? computedStyle.getPropertyValue(name)\n : computedStyle[name as any]\n}\n"],"names":[],"mappings":";;AAEM,SAAU,gBAAgB,CAC5B,OAAiC,EACjC,IAAY,EAAA;IAEZ,MAAM,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC;IACtD,OAAO,QAAQ,CAAC,IAAI;AAChB,UAAE,aAAa,CAAC,gBAAgB,CAAC,IAAI;AACrC,UAAE,aAAa,CAAC,IAAW,CAAC;AACpC;;;;"}
.pnpm-store/v11/files/58/c03163b57efd02036cb9f944e5d1ad955a71e0fafe5cfd8f8aeda06d24cf83f09c25f1e4178d5a6ad92e514ca49fff099382b06a30ba73906c9e70865a6616
+34
View File
@@ -0,0 +1,34 @@
import { JSX } from "./intrinsic-elements.js";
import { RefObject } from "./hooks/index.js";
import { Context } from "./context.js";
import { Child, FC, JSXNode } from "./base.js";
//#region src/jsx/types.d.ts
export type PropsWithChildren<P = unknown> = P & {
children?: Child | undefined;
};
export type CSSProperties = JSX.CSSProperties;
/**
* React types
*/
type ReactElement<P = any, T = string | Function> = JSXNode & {
type: T;
props: P;
key: string | null;
};
type ReactNode = ReactElement | string | number | boolean | null | undefined;
type ComponentClass<_P = {}, _S = {}> = unknown;
export type Event = globalThis.Event;
export type MouseEvent = globalThis.MouseEvent;
export type KeyboardEvent = globalThis.KeyboardEvent;
export type FocusEvent = globalThis.FocusEvent;
export type ClipboardEvent = globalThis.ClipboardEvent;
export type InputEvent = globalThis.InputEvent;
export type PointerEvent = globalThis.PointerEvent;
export type TouchEvent = globalThis.TouchEvent;
export type WheelEvent = globalThis.WheelEvent;
export type AnimationEvent = globalThis.AnimationEvent;
export type TransitionEvent = globalThis.TransitionEvent;
export type DragEvent = globalThis.DragEvent;
//#endregion
export type { Child, ComponentClass, Context, FC, JSXNode, ReactElement, ReactNode, RefObject };
export {};
.pnpm-store/v11/files/58/c981608e5ce63eb1914ea1f6921f70cc312e925ba7bb1b08c17f55616292943202988ccf6c6e5e502ce2710e76d63a5512c0c6dda88e3a163ccb1afeb69ad1
+9
View File
@@ -0,0 +1,9 @@
import { Stringifier } from './postcss.js'
interface Stringify extends Stringifier {
default: Stringify
}
declare let stringify: Stringify
export = stringify
.pnpm-store/v11/files/58/cb383eee2ba65a102e0f17ee032b3d94c38836f7dcb6d045a9e399db3ca9a61f5b637e7736accedc8aed30d3cae4d0002cc75ba7e81272f88ee6dda9c667d5
+151
View File
@@ -0,0 +1,151 @@
### Version 4.0.0 (2018-01-28) ###
- Added: Support for ES2018. The only change needed was recognizing the `s`
regex flag.
- Changed: _All_ tokens returned by the `matchToToken` function now have a
`closed` property. It is set to `undefined` for the tokens where “closed”
doesn’t make sense. This means that all tokens objects have the same shape,
which might improve performance.
These are the breaking changes:
- `'/a/s'.match(jsTokens)` no longer returns `['/', 'a', '/', 's']`, but
`['/a/s']`. (There are of course other variations of this.)
- Code that rely on some token objects not having the `closed` property could
now behave differently.
### Version 3.0.2 (2017-06-28) ###
- No code changes. Just updates to the readme.
### Version 3.0.1 (2017-01-30) ###
- Fixed: ES2015 unicode escapes with more than 6 hex digits are now matched
correctly.
### Version 3.0.0 (2017-01-11) ###
This release contains one breaking change, that should [improve performance in
V8][v8-perf]:
> So how can you, as a JavaScript developer, ensure that your RegExps are fast?
> If you are not interested in hooking into RegExp internals, make sure that
> neither the RegExp instance, nor its prototype is modified in order to get the
> best performance:
>
> ```js
> var re = /./g;
> re.exec(''); // Fast path.
> re.new_property = 'slow';
> ```
This module used to export a single regex, with `.matchToToken` bolted
on, just like in the above example. This release changes the exports of
the module to avoid this issue.
Before:
```js
import jsTokens from "js-tokens"
// or:
var jsTokens = require("js-tokens")
var matchToToken = jsTokens.matchToToken
```
After:
```js
import jsTokens, {matchToToken} from "js-tokens"
// or:
var jsTokens = require("js-tokens").default
var matchToToken = require("js-tokens").matchToToken
```
[v8-perf]: http://v8project.blogspot.se/2017/01/speeding-up-v8-regular-expressions.html
### Version 2.0.0 (2016-06-19) ###
- Added: Support for ES2016. In other words, support for the `**` exponentiation
operator.
These are the breaking changes:
- `'**'.match(jsTokens)` no longer returns `['*', '*']`, but `['**']`.
- `'**='.match(jsTokens)` no longer returns `['*', '*=']`, but `['**=']`.
### Version 1.0.3 (2016-03-27) ###
- Improved: Made the regex ever so slightly smaller.
- Updated: The readme.
### Version 1.0.2 (2015-10-18) ###
- Improved: Limited npm package contents for a smaller download. Thanks to
@zertosh!
### Version 1.0.1 (2015-06-20) ###
- Fixed: Declared an undeclared variable.
### Version 1.0.0 (2015-02-26) ###
- Changed: Merged the 'operator' and 'punctuation' types into 'punctuator'. That
type is now equivalent to the Punctuator token in the ECMAScript
specification. (Backwards-incompatible change.)
- Fixed: A `-` followed by a number is now correctly matched as a punctuator
followed by a number. It used to be matched as just a number, but there is no
such thing as negative number literals. (Possibly backwards-incompatible
change.)
### Version 0.4.1 (2015-02-21) ###
- Added: Support for the regex `u` flag.
### Version 0.4.0 (2015-02-21) ###
- Improved: `jsTokens.matchToToken` performance.
- Added: Support for octal and binary number literals.
- Added: Support for template strings.
### Version 0.3.1 (2015-01-06) ###
- Fixed: Support for unicode spaces. They used to be allowed in names (which is
very confusing), and some unicode newlines were wrongly allowed in strings and
regexes.
### Version 0.3.0 (2014-12-19) ###
- Changed: The `jsTokens.names` array has been replaced with the
`jsTokens.matchToToken` function. The capturing groups of `jsTokens` are no
longer part of the public API; instead use said function. See this [gist] for
an example. (Backwards-incompatible change.)
- Changed: The empty string is now considered an “invalid” token, instead an
“empty” token (its own group). (Backwards-incompatible change.)
- Removed: component support. (Backwards-incompatible change.)
[gist]: https://gist.github.com/lydell/be49dbf80c382c473004
### Version 0.2.0 (2014-06-19) ###
- Changed: Match ES6 function arrows (`=>`) as an operator, instead of its own
category (“functionArrow”), for simplicity. (Backwards-incompatible change.)
- Added: ES6 splats (`...`) are now matched as an operator (instead of three
punctuations). (Backwards-incompatible change.)
### Version 0.1.0 (2014-03-08) ###
- Initial release.
.pnpm-store/v11/files/58/cf7e322ad1e5f2ca8f2d4889a9a81555b9d0e0f7266d87f083da5692d4ccb98940ae107108c7592ac1359915167e7ec1edb17a87a7c7f50a0fb0137cb9ff41
+14
View File
@@ -0,0 +1,14 @@
import { assignRef } from './assignRef';
import { createCallbackRef } from './createRef';
/**
* Transforms one ref to another
* @example
* ```tsx
* const ResizableWithRef = forwardRef((props, ref) =>
* <Resizable {...props} ref={transformRef(ref, i => i ? i.resizable : null)}/>
* );
* ```
*/
export function transformRef(ref, transformer) {
return createCallbackRef((value) => assignRef(ref, transformer(value)));
}
.pnpm-store/v11/files/58/d5cf583e270f754d61727aa9ce2e535b1df747e8fddf16ba97c5d151800dc48ccab2a5e62a4ce501e2a6d4e4a823324a18a7b244864aab136593cef506e366
+59
View File
@@ -0,0 +1,59 @@
/*
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 ConditionalPlugin {
/**
* @param {string | ResolveStepHook} source source
* @param {Partial<ResolveRequest>} test compare object
* @param {string | null} message log message
* @param {boolean} allowAlternatives when false, do not continue with the current step when "test" matches
* @param {string | ResolveStepHook} target target
*/
constructor(source, test, message, allowAlternatives, target) {
this.source = source;
this.test = test;
this.message = message;
this.allowAlternatives = allowAlternatives;
this.target = target;
}
/**
* @param {Resolver} resolver the resolver
* @returns {void}
*/
apply(resolver) {
const target = resolver.ensureHook(this.target);
const { test, message, allowAlternatives } = this;
const keys = /** @type {(keyof ResolveRequest)[]} */ (Object.keys(test));
resolver
.getHook(this.source)
.tapAsync("ConditionalPlugin", (request, resolveContext, callback) => {
for (const prop of keys) {
if (request[prop] !== test[prop]) return callback();
}
resolver.doResolve(
target,
request,
message,
resolveContext,
allowAlternatives
? callback
: (err, result) => {
if (err) return callback(err);
// Don't allow other alternatives
if (result === undefined) return callback(null, null);
callback(null, result);
},
);
});
}
};
.pnpm-store/v11/files/58/da43d417376a5e03721fe3b2e7936cbbb0793bca57d1b6974e8d446762c2c3b9852b4bad2b9ce74632a0402c4760632f624d163772fa99b0032644390a506d
+19
View File
@@ -0,0 +1,19 @@
import type { TSESLint } from '@typescript-eslint/utils';
type AccessibilityLevel = 'explicit' | 'no-public' | 'off';
export interface Config {
accessibility?: AccessibilityLevel;
ignoredMethodNames?: string[];
overrides?: {
accessors?: AccessibilityLevel;
constructors?: AccessibilityLevel;
methods?: AccessibilityLevel;
parameterProperties?: AccessibilityLevel;
properties?: AccessibilityLevel;
};
}
export type Options = [Config];
export type MessageIds = 'addExplicitAccessibility' | 'missingAccessibility' | 'unwantedPublicAccessibility';
declare const _default: TSESLint.RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
name: string;
};
export default _default;
.pnpm-store/v11/files/58/dd934964cf934e42c58dfe0893ccc8d760cd025362cf603eb89c1e9da5fab46cb4d528e2481080f1e4091b3e76eef1676f2bd026ef14359c9d13fb177da1a0
+14
View File
@@ -0,0 +1,14 @@
import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
import { g as getWorkerState } from './utils.BX5Fg8C4.js';
import '@vitest/utils/timers';
class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
getHeader() {
return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
}
resolvePath(filepath) {
return getWorkerState().rpc.resolveSnapshotPath(filepath);
}
}
export { VitestNodeSnapshotEnvironment };
.pnpm-store/v11/files/58/e30db40a5dd445483225308ab426c89ed834c32c1076f6a5776f7ad8f7b404aa6ca428f5556f4564d21a5fd54737e3826f4d4601fb33fc28c1e1d602d87452
+157
View File
@@ -0,0 +1,157 @@
/**
* @fileoverview Rule to disallow `parseInt()` in favor of binary, octal, and hexadecimal literals
* @author Annie Zhang, Henry Zhu
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
const radixMap = new Map([
[2, { system: "binary", literalPrefix: "0b" }],
[8, { system: "octal", literalPrefix: "0o" }],
[16, { system: "hexadecimal", literalPrefix: "0x" }],
]);
/**
* Checks to see if a CallExpression's callee node is `parseInt` or
* `Number.parseInt`.
* @param {ASTNode} calleeNode The callee node to evaluate.
* @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
* false otherwise.
*/
function isParseInt(calleeNode) {
return (
astUtils.isSpecificId(calleeNode, "parseInt") ||
astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
);
}
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
type: "suggestion",
docs: {
description:
"Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
recommended: false,
frozen: true,
url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals",
},
schema: [],
messages: {
useLiteral:
"Use {{system}} literals instead of {{functionName}}().",
},
fixable: "code",
},
create(context) {
const sourceCode = context.sourceCode;
//----------------------------------------------------------------------
// Public
//----------------------------------------------------------------------
return {
"CallExpression[arguments.length=2]"(node) {
const [strNode, radixNode] = node.arguments,
str = astUtils.getStaticStringValue(strNode),
radix = radixNode.value;
if (
str !== null &&
astUtils.isStringLiteral(strNode) &&
radixNode.type === "Literal" &&
typeof radix === "number" &&
radixMap.has(radix) &&
isParseInt(node.callee)
) {
const { system, literalPrefix } = radixMap.get(radix);
context.report({
node,
messageId: "useLiteral",
data: {
system,
functionName: sourceCode.getText(node.callee),
},
fix(fixer) {
if (sourceCode.getCommentsInside(node).length) {
return null;
}
const replacement = `${literalPrefix}${str}`;
if (+replacement !== parseInt(str, radix)) {
/*
* If the newly-produced literal would be invalid, (e.g. 0b1234),
* or it would yield an incorrect parseInt result for some other reason, don't make a fix.
*
* If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
* per the specification doesn't support numeric separators. Thus, the above condition will be `true`
* (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
* Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
* doesn't support numeric separators, but it does parse part of the string before the first `_`,
* so the autofix would be invalid:
*
* parseInt("1_1", 2) // === 1
* 0b1_1 // === 3
*/
return null;
}
const tokenBefore = sourceCode.getTokenBefore(node),
tokenAfter = sourceCode.getTokenAfter(node);
let prefix = "",
suffix = "";
if (
tokenBefore &&
tokenBefore.range[1] === node.range[0] &&
!astUtils.canTokensBeAdjacent(
tokenBefore,
replacement,
)
) {
prefix = " ";
}
if (
tokenAfter &&
node.range[1] === tokenAfter.range[0] &&
!astUtils.canTokensBeAdjacent(
replacement,
tokenAfter,
)
) {
suffix = " ";
}
return fixer.replaceText(
node,
`${prefix}${replacement}${suffix}`,
);
},
});
}
},
};
},
};
.pnpm-store/v11/files/58/e3345093650d2dedf1dc076394c27561624a2bc4767072473a600c15e4574e5882c2f297d37885520a9d90a330654483108c40fcdade4101f614a00ef55a71
+161
View File
@@ -0,0 +1,161 @@
## Any Promise
[![Build Status](https://secure.travis-ci.org/kevinbeaty/any-promise.svg)](http://travis-ci.org/kevinbeaty/any-promise)
Let your library support any ES 2015 (ES6) compatible `Promise` and leave the choice to application authors. The application can *optionally* register its preferred `Promise` implementation and it will be exported when requiring `any-promise` from library code.
If no preference is registered, defaults to the global `Promise` for newer Node.js versions. The browser version defaults to the window `Promise`, so polyfill or register as necessary.
### Usage with global Promise:
Assuming the global `Promise` is the desired implementation:
```bash
# Install any libraries depending on any-promise
$ npm install mz
```
The installed libraries will use global Promise by default.
```js
// in library
var Promise = require('any-promise') // the global Promise
function promiseReturningFunction(){
return new Promise(function(resolve, reject){...})
}
```
### Usage with registration:
Assuming `bluebird` is the desired Promise implementation:
```bash
# Install preferred promise library
$ npm install bluebird
# Install any-promise to allow registration
$ npm install any-promise
# Install any libraries you would like to use depending on any-promise
$ npm install mz
```
Register your preference in the application entry point before any other `require` of packages that load `any-promise`:
```javascript
// top of application index.js or other entry point
require('any-promise/register/bluebird')
// -or- Equivalent to above, but allows customization of Promise library
require('any-promise/register')('bluebird', {Promise: require('bluebird')})
```
Now that the implementation is registered, you can use any package depending on `any-promise`:
```javascript
var fsp = require('mz/fs') // mz/fs will use registered bluebird promises
var Promise = require('any-promise') // the registered bluebird promise
```
It is safe to call `register` multiple times, but it must always be with the same implementation.
Again, registration is *optional*. It should only be called by the application user if overriding the global `Promise` implementation is desired.
### Optional Application Registration
As an application author, you can *optionally* register a preferred `Promise` implementation on application startup (before any call to `require('any-promise')`:
You must register your preference before any call to `require('any-promise')` (by you or required packages), and only one implementation can be registered. Typically, this registration would occur at the top of the application entry point.
#### Registration shortcuts
If you are using a known `Promise` implementation, you can register your preference with a shortcut:
```js
require('any-promise/register/bluebird')
// -or-
import 'any-promise/register/q';
```
Shortcut registration is the preferred registration method as it works in the browser and Node.js. It is also convenient for using with `import` and many test runners, that offer a `--require` flag:
```
$ ava --require=any-promise/register/bluebird test.js
```
Current known implementations include `bluebird`, `q`, `when`, `rsvp`, `es6-promise`, `promise`, `native-promise-only`, `pinkie`, `vow` and `lie`. If you are not using a known implementation, you can use another registration method described below.
#### Basic Registration
As an alternative to registration shortcuts, you can call the `register` function with the preferred `Promise` implementation. The benefit of this approach is that a `Promise` library can be required by name without being a known implementation. This approach does NOT work in the browser. To use `any-promise` in the browser use either registration shortcuts or specify the `Promise` constructor using advanced registration (see below).
```javascript
require('any-promise/register')('when')
// -or- require('any-promise/register')('any other ES6 compatible library (known or otherwise)')
```
This registration method will try to detect the `Promise` constructor from requiring the specified implementation. If you would like to specify your own constructor, see advanced registration.
#### Advanced Registration
To use the browser version, you should either install a polyfill or explicitly register the `Promise` constructor:
```javascript
require('any-promise/register')('bluebird', {Promise: require('bluebird')})
```
This could also be used for registering a custom `Promise` implementation or subclass.
Your preference will be registered globally, allowing a single registration even if multiple versions of `any-promise` are installed in the NPM dependency tree or are using multiple bundled JavaScript files in the browser. You can bypass this global registration in options:
```javascript
require('../register')('es6-promise', {Promise: require('es6-promise').Promise, global: false})
```
### Library Usage
To use any `Promise` constructor, simply require it:
```javascript
var Promise = require('any-promise');
return Promise
.all([xf, f, init, coll])
.then(fn);
return new Promise(function(resolve, reject){
try {
resolve(item);
} catch(e){
reject(e);
}
});
```
Except noted below, libraries using `any-promise` should only use [documented](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) functions as there is no guarantee which implementation will be chosen by the application author. Libraries should never call `register`, only the application user should call if desired.
#### Advanced Library Usage
If your library needs to branch code based on the registered implementation, you can retrieve it using `var impl = require('any-promise/implementation')`, where `impl` will be the package name (`"bluebird"`, `"when"`, etc.) if registered, `"global.Promise"` if using the global version on Node.js, or `"window.Promise"` if using the browser version. You should always include a default case, as there is no guarantee what package may be registered.
### Support for old Node.js versions
Node.js versions prior to `v0.12` may have contained buggy versions of the global `Promise`. For this reason, the global `Promise` is not loaded automatically for these old versions. If using `any-promise` in Node.js versions versions `<= v0.12`, the user should register a desired implementation.
If an implementation is not registered, `any-promise` will attempt to discover an installed `Promise` implementation. If no implementation can be found, an error will be thrown on `require('any-promise')`. While the auto-discovery usually avoids errors, it is non-deterministic. It is recommended that the user always register a preferred implementation for older Node.js versions.
This auto-discovery is only available for Node.jS versions prior to `v0.12`. Any newer versions will always default to the global `Promise` implementation.
### Related
- [any-observable](https://github.com/sindresorhus/any-observable) - `any-promise` for Observables.
.pnpm-store/v11/files/58/e86b71c9aa7820bfb0988b30dda0d38286292cb68ca88de34091ee2db7e2d50ddbfbdf4686a6162148ce8e68ecc14c069ef58fdcd5693c7b0f77bbbccd4ad6
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"dateSplits.cjs","sources":["../../src/data/dateSplits.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA,iBAAe;AACb,EAAA,CAAC,EAAE;AACD;EACA,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;AACR,EAAA,CAAC,CAAC,EAAE,CAAC,CAAC;GACP;AACD,EAAA,CAAC,EAAE,CACD,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;EACR,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;AACR;AACA,EAAA,CAAC,CAAC,EAAE,CAAC,CAAC;GACP;AACD,EAAA,CAAC,EAAE,CACD,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;EACR,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;AACR,EAAA,CAAC,CAAC,EAAE,CAAC,CAAC;GACP;AACD;AACA,EAAA,CAAC,EAAE,CACD,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;EACR,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;EACR,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;AACR,EAAA,CAAC,CAAC,EAAE,CAAC,CAAC;GACP;AACD,EAAA,CAAC,EAAE,CACD,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;AACR,EAAA,CAAC,CAAC,EAAE,CAAC,CAAC;AAAE;CAEX;;;;"}
.pnpm-store/v11/files/58/ea0b0029f95f8c279b884384d9e6bb39060c6261b14d9e1d2d6a17552b44f98c9251f9219c9a6251df9d8cb170d906daafd9a758aa5d311438a2c037659702
+125
View File
@@ -0,0 +1,125 @@
import { expect, test } from "vitest";
import * as z from "zod/v4";
test("record should parse objects with non-function constructor field", () => {
const schema = z.record(z.string(), z.any());
expect(() => schema.parse({ constructor: "string", key: "value" })).not.toThrow();
const result1 = schema.parse({ constructor: "string", key: "value" });
expect(result1).toEqual({ constructor: "string", key: "value" });
expect(() => schema.parse({ constructor: 123, key: "value" })).not.toThrow();
const result2 = schema.parse({ constructor: 123, key: "value" });
expect(result2).toEqual({ constructor: 123, key: "value" });
expect(() => schema.parse({ constructor: null, key: "value" })).not.toThrow();
const result3 = schema.parse({ constructor: null, key: "value" });
expect(result3).toEqual({ constructor: null, key: "value" });
expect(() => schema.parse({ constructor: {}, key: "value" })).not.toThrow();
const result4 = schema.parse({ constructor: {}, key: "value" });
expect(result4).toEqual({ constructor: {}, key: "value" });
expect(() => schema.parse({ constructor: [], key: "value" })).not.toThrow();
const result5 = schema.parse({ constructor: [], key: "value" });
expect(result5).toEqual({ constructor: [], key: "value" });
expect(() => schema.parse({ constructor: true, key: "value" })).not.toThrow();
const result6 = schema.parse({ constructor: true, key: "value" });
expect(result6).toEqual({ constructor: true, key: "value" });
});
test("record should still work with normal objects", () => {
const schema = z.record(z.string(), z.string());
expect(() => schema.parse({ normalKey: "value" })).not.toThrow();
const result1 = schema.parse({ normalKey: "value" });
expect(result1).toEqual({ normalKey: "value" });
expect(() => schema.parse({ key1: "value1", key2: "value2" })).not.toThrow();
const result2 = schema.parse({ key1: "value1", key2: "value2" });
expect(result2).toEqual({ key1: "value1", key2: "value2" });
});
test("record should validate values according to schema even with constructor field", () => {
const stringSchema = z.record(z.string(), z.string());
expect(() => stringSchema.parse({ constructor: "string", key: "value" })).not.toThrow();
expect(() => stringSchema.parse({ constructor: 123, key: "value" })).toThrow();
});
test("record should work with different key types and constructor field", () => {
const enumSchema = z.record(z.enum(["constructor", "key"]), z.string());
expect(() => enumSchema.parse({ constructor: "value1", key: "value2" })).not.toThrow();
const result = enumSchema.parse({ constructor: "value1", key: "value2" });
expect(result).toEqual({ constructor: "value1", key: "value2" });
});
test("record should skip non-enumerable own properties", () => {
const schema = z.record(z.string(), z.string());
const input = { key: "value" };
Object.defineProperty(input, "~standard", {
value: { validate: () => {}, vendor: "zod", version: 1 },
enumerable: false,
writable: false,
configurable: false,
});
const result = schema.safeParse(input);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data).toEqual({ key: "value" });
expect("~standard" in result.data).toBe(false);
}
});
test("record fails on enumerable invalid values even when non-enumerable properties are present", () => {
const schema = z.record(z.string(), z.string());
const input = { key: "value", bad: 123 };
Object.defineProperty(input, "hidden", {
value: "should be ignored",
enumerable: false,
});
const result = schema.safeParse(input);
expect(result.success).toBe(false);
});
test("record validates enumerable Symbol keys and skips non-enumerable Symbol keys", () => {
const enumerableSym = Symbol.for("included");
const nonEnumerableSym = Symbol.for("hidden");
const schema = z.record(z.symbol(), z.string());
const input: Record<symbol, unknown> = { [enumerableSym]: "value" };
Object.defineProperty(input, nonEnumerableSym, {
value: 123,
enumerable: false,
});
const result = schema.safeParse(input);
expect(result.success).toBe(true);
if (result.success) {
expect(result.data[enumerableSym]).toBe("value");
expect(Object.prototype.hasOwnProperty.call(result.data, nonEnumerableSym)).toBe(false);
}
});
test("z.json() accepts z.toJSONSchema() output (issue #5714)", () => {
const schema = z.object({ name: z.string() });
const jsonSchema = z.toJSONSchema(schema);
expect(z.json().safeParse(jsonSchema).success).toBe(true);
});
.pnpm-store/v11/files/58/eafd3d7ed7058f6da7e34c58ce2c0bff14ff6354c55ba10039d5ed075fc52a776f860c0f3a99c5e407bf4f1fb58d23c1b75c027d646ded1e869a921ec45d04
+1
View File
@@ -0,0 +1 @@
module.exports={A:{A:{"2":"_E"},B:{"1":"_I","2":"_K"},C:{"2":"_PL _fF _EC _yE _zE","386":"IB JB"},D:{"2":"_Q"},E:{"2":"_R"},F:{"2":"_c"},G:{"2":"_M"},H:{"2":"1D"},I:{"2":"_P"},J:{"2":"_B"},K:{"2":"_N"},L:{"2":"I"},M:{"2":"YC"},N:{"2":"_A"},O:{"2":"bC"},P:{"2":"_F"},Q:{"2":"JE"},R:{"2":"KE"},S:{"2":"_C"}},B:6,C:"Dynamic Adaptive Streaming over HTTP (MPEG-DASH)",D:true};
.pnpm-store/v11/files/58/eb7b33ffdfb7633845a836f8e3eda93b6255e4185b6018d29665ec59ee425c66693aad1aad523480c56c36314d8431bb5a7c7a7811a7f2b5f80b5176f6a371
+3
View File
@@ -0,0 +1,3 @@
import type { Options } from "../index";
import type TokenProcessor from "../TokenProcessor";
export declare function getNonTypeIdentifiers(tokens: TokenProcessor, options: Options): Set<string>;
.pnpm-store/v11/files/58/ecfa5699b1a174ede01152035bda2b8b15e1692b452300d43da217c424ee8ddcf9ca0bb0555a8ba27e39a41e1699f0eb50383f4d1fb62643ee86cc0c730711
+216
View File
@@ -0,0 +1,216 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow strict
* @format
*/
/**
* This transform strips Flow types that are not supported past Babel 7.
*
* It is expected that all transforms create valid ESTree AST output. If
* the transform requires outputting Babel specific AST nodes then it
* should live in `ConvertESTreeToBabel.js`
*/
'use strict';
import type {ParserOptions} from '../ParserOptions';
import type {
Program,
ESNode,
DeclareEnum,
DeclareNamespace,
DeclareVariable,
AnyTypeAnnotation,
GenericTypeAnnotation,
QualifiedTypeIdentifier,
QualifiedTypeofIdentifier,
AFunction,
} from 'hermes-estree';
import {SimpleTransform} from '../transform/SimpleTransform';
import {createSyntaxError} from '../utils/createSyntaxError';
const nodeWith = SimpleTransform.nodeWith;
// Rely on the mapper to fix up parent relationships.
const EMPTY_PARENT: $FlowFixMe = null;
function createSimpleGenericTypeAnnotation(
name: string,
nodeForLoc: ESNode,
): GenericTypeAnnotation {
return {
type: 'GenericTypeAnnotation',
id: {
type: 'Identifier',
name,
optional: false,
typeAnnotation: null,
loc: nodeForLoc.loc,
range: nodeForLoc.range,
parent: EMPTY_PARENT,
},
typeParameters: null,
loc: nodeForLoc.loc,
range: nodeForLoc.range,
parent: nodeForLoc.parent,
};
}
function createAnyTypeAnnotation(node: ESNode): AnyTypeAnnotation {
return {
type: 'AnyTypeAnnotation',
loc: node.loc,
range: node.range,
parent: node.parent,
};
}
/**
* Convert DeclareEnum nodes to DeclareVariable
*/
function mapDeclareEnum(node: DeclareEnum): DeclareVariable {
return {
type: 'DeclareVariable',
kind: 'const',
id: nodeWith(node.id, {
typeAnnotation: {
type: 'TypeAnnotation',
typeAnnotation: createAnyTypeAnnotation(node.body),
loc: node.body.loc,
range: node.body.range,
parent: EMPTY_PARENT,
},
}),
loc: node.loc,
range: node.range,
parent: node.parent,
};
}
/**
* Convert DeclareNamespace nodes to DeclareVariable
*/
function mapDeclareNamespace(node: DeclareNamespace): DeclareVariable {
return {
type: 'DeclareVariable',
kind: 'const',
id: nodeWith(node.id, {
typeAnnotation: {
type: 'TypeAnnotation',
typeAnnotation: createAnyTypeAnnotation(node.body),
loc: node.body.loc,
range: node.body.range,
parent: EMPTY_PARENT,
},
}),
loc: node.loc,
range: node.range,
parent: node.parent,
};
}
/**
* Remove `this` param from functions.
*/
function mapFunction(node: AFunction): AFunction {
// Remove the first parameter if it is a this-type annotation,
// which is not recognized by Babel.
if (node.params.length !== 0 && node.params[0].name === 'this') {
return nodeWith(node, {
params: node.params.slice(1),
});
}
return node;
}
/**
* Convert to QualifiedTypeIdentifier
*/
function mapQualifiedTypeofIdentifier(
node: QualifiedTypeofIdentifier,
): QualifiedTypeIdentifier {
return {
type: 'QualifiedTypeIdentifier',
qualification:
node.qualification.type === 'QualifiedTypeofIdentifier'
? mapQualifiedTypeofIdentifier(node.qualification)
: node.qualification,
id: node.id,
loc: node.loc,
range: node.range,
parent: node.parent,
};
}
export function transformProgram(
program: Program,
_options: ParserOptions,
): Program {
return SimpleTransform.transformProgram(program, {
transform(node: ESNode) {
switch (node.type) {
case 'SymbolTypeAnnotation': {
// Convert to simple generic type annotation
return createSimpleGenericTypeAnnotation('symbol', node);
}
case 'BigIntTypeAnnotation': {
// Convert to simple generic type annotation
return createSimpleGenericTypeAnnotation('bigint', node);
}
case 'ObjectTypeAnnotation': {
const shouldStrip = node.properties.some(
prop => prop.type === 'ObjectTypeMappedTypeProperty',
);
if (shouldStrip) {
return createAnyTypeAnnotation(node);
}
return node;
}
case 'ObjectTypeMappedTypeProperty': {
throw createSyntaxError(
node,
`Invalid AST structure, ObjectTypeMappedTypeProperty found outside of an ObjectTypeAnnotation`,
);
}
case 'IndexedAccessType':
case 'OptionalIndexedAccessType':
case 'KeyofTypeAnnotation':
case 'ConditionalTypeAnnotation':
case 'InferTypeAnnotation':
case 'TupleTypeLabeledElement':
case 'TupleTypeSpreadElement':
case 'ComponentTypeAnnotation':
case 'HookTypeAnnotation':
case 'TypeOperator':
case 'TypePredicate': {
// Babel does not support these generic types, so convert to any
return createAnyTypeAnnotation(node);
}
case 'QualifiedTypeofIdentifier': {
return mapQualifiedTypeofIdentifier(node);
}
case 'DeclareEnum': {
return mapDeclareEnum(node);
}
case 'DeclareNamespace': {
return mapDeclareNamespace(node);
}
case 'FunctionDeclaration':
case 'FunctionExpression': {
return mapFunction(node);
}
default: {
return node;
}
}
},
});
}
.pnpm-store/v11/files/58/f01803cfa15686817544f40c3a6b451b59bd6dbaa7e1e8da36cb2d6bb6d72b8d205c76304d14f96d101553a4ef3f2267dc254cf8affaa1491d4fba52567bd7
+25
View File
@@ -0,0 +1,25 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const Drumstick = createLucideIcon("Drumstick", [
[
"path",
{ d: "M15.4 15.63a7.875 6 135 1 1 6.23-6.23 4.5 3.43 135 0 0-6.23 6.23", key: "1dtqwm" }
],
[
"path",
{
d: "m8.29 12.71-2.6 2.6a2.5 2.5 0 1 0-1.65 4.65A2.5 2.5 0 1 0 8.7 18.3l2.59-2.59",
key: "1oq1fw"
}
]
]);
export { Drumstick as default };
//# sourceMappingURL=drumstick.js.map
.pnpm-store/v11/files/58/f052f0f5ae9b2a36d2dfdd0e847ff60e841317a8ce08f50be4d1f95681ab2f1a7aa28441d197fac66fb68d5ffac67e8263d7aa5d21229a23e65ecae1f9d03e
+55
View File
@@ -0,0 +1,55 @@
const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
const require_utils = require("./utils.cjs");
let _tanstack_router_core = require("@tanstack/router-core");
let react = require("react");
react = require_runtime.__toESM(react);
//#region src/lazyRouteComponent.tsx
/**
* Wrap a dynamic import to create a route component that supports
* `.preload()` and friendly reload-on-module-missing behavior.
*
* @param importer Function returning a module promise
* @param exportName Named export to use (default: `default`)
* @returns A lazy route component compatible with TanStack Router
* @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction
*/
function lazyRouteComponent(importer, exportName) {
let loadPromise;
let comp;
let error;
let reload;
const load = () => {
if (!loadPromise) loadPromise = importer().then((res) => {
loadPromise = void 0;
comp = res[exportName ?? "default"];
}).catch((err) => {
error = err;
if ((0, _tanstack_router_core.isModuleNotFoundError)(error)) {
if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
const storageKey = `tanstack_router_reload:${error.message}`;
if (!sessionStorage.getItem(storageKey)) {
sessionStorage.setItem(storageKey, "1");
reload = true;
}
}
}
});
return loadPromise;
};
const lazyComp = function Lazy(props) {
if (reload) {
window.location.reload();
throw new Promise(() => {});
}
if (error) throw error;
if (!comp) if (require_utils.reactUse) require_utils.reactUse(load());
else throw load();
return react.createElement(comp, props);
};
lazyComp.preload = load;
return lazyComp;
}
//#endregion
exports.lazyRouteComponent = lazyRouteComponent;
//# sourceMappingURL=lazyRouteComponent.cjs.map
.pnpm-store/v11/files/58/f1560dfcd60a7babe63d227628a660292e81252dadb4d1f955919d0af2a483eef3c664968a26d6e9f3f113648e512d52335ae896637567c0b2fd1e3f925185
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"parking-square-off.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}
.pnpm-store/v11/files/58/f727f450bd3443b79a1d6701047c339f7cb9adcf181123060008be8c3f8c50513e465436c3e76376f05caa0dfc744ae2191d32b13efbfa8ce036c022a4cd85
+1
View File
@@ -0,0 +1 @@
{"version":3,"file":"wind-arrow-down.js","sources":["../../../src/icons/wind-arrow-down.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name WindArrowDown\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTAgMnY4IiAvPgogIDxwYXRoIGQ9Ik0xMi44IDIxLjZBMiAyIDAgMSAwIDE0IDE4SDIiIC8+CiAgPHBhdGggZD0iTTE3LjUgMTBhMi41IDIuNSAwIDEgMSAyIDRIMiIgLz4KICA8cGF0aCBkPSJtNiA2IDQgNCA0LTQiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/wind-arrow-down\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst WindArrowDown = createLucideIcon('WindArrowDown', [\n ['path', { d: 'M10 2v8', key: 'd4bbey' }],\n ['path', { d: 'M12.8 21.6A2 2 0 1 0 14 18H2', key: '19kp1d' }],\n ['path', { d: 'M17.5 10a2.5 2.5 0 1 1 2 4H2', key: '19kpjc' }],\n ['path', { d: 'm6 6 4 4 4-4', key: 'k13n16' }],\n]);\n\nexport default WindArrowDown;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAgB,iBAAiB,eAAiB,CAAA,CAAA,CAAA;AAAA,CAAA,CACtD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAW,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CACxC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAgC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC7D,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAgC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC7D,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAgB,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AAC/C,CAAC,CAAA,CAAA;;"}
.pnpm-store/v11/files/58/ffefaa206c73d89467b3b58babb4e504eb6a0bdf3f310e9fe16b1773da4f49e6e071e7cebecd7a4b7267d08b8d1a8c0f9a71c67b27a95cfe6be166139b505e
+19
View File
@@ -0,0 +1,19 @@
/**
* @license lucide-react v0.469.0 - ISC
*
* This source code is licensed under the ISC license.
* See the LICENSE file in the root directory of this source tree.
*/
import createLucideIcon from '../createLucideIcon.js';
const MailSearch = createLucideIcon("MailSearch", [
["path", { d: "M22 12.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h7.5", key: "w80f2v" }],
["path", { d: "m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7", key: "1ocrg3" }],
["path", { d: "M18 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z", key: "8lzu5m" }],
["circle", { cx: "18", cy: "18", r: "3", key: "1xkwt0" }],
["path", { d: "m22 22-1.5-1.5", key: "1x83k4" }]
]);
export { MailSearch as default };
//# sourceMappingURL=mail-search.js.map