mmintel/klz-cables.com
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases 1 Wiki Activity

fix(products): fix breadcrumbs and product filtering (backport from main)
Some checks failed
Build & Deploy / 🔍 Prepare (push) Successful in 20s
Details
Build & Deploy / 🧪 QA (push) Failing after 34s
Details
Build & Deploy / 🏗️ Build (push) Has started running
Details
Build & Deploy / 🚀 Deploy (push) Has been cancelled
Details
Build & Deploy / 🧪 Smoke Test (push) Has been cancelled
Details
Build & Deploy / ⚡ Lighthouse (push) Has been cancelled
Details
Build & Deploy / 🔔 Notify (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Marc Mintel
2026-02-24 16:04:21 +01:00
parent 915eb61613
commit 5397309103
43805 changed files with 4324295 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.pnpm-store/v10/files/51/01014a516b057da60a6126d3a11c5b53c1a1706bf2a73d3a8d9ae9b687bdd27fc67851f794e94a07b02792de82162d3e831f5c5873a5ff469f18b418d617f4 Normal file
View File

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

33
.pnpm-store/v10/files/51/04ac14c7740da0a1d6aec9efaf6049599247fa3dfe1f7050b7209ed08c261b6945d13632748a6ad7e7558cb648c8bb04d48d7792e16fc2bd24a4ef85d71b90 Normal file
View File

@@ -0,0 +1,33 @@
Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
/* eslint-disable @sentry-internal/sdk/no-unsafe-random-apis */
// Polyfill for Node.js perf_hooks module in edge runtime
// This mirrors the polyfill from packages/vercel-edge/rollup.npm.config.mjs
const __sentry__timeOrigin = Date.now();
// Ensure performance global is available
if (typeof globalThis !== 'undefined' && globalThis.performance === undefined) {
globalThis.performance = {
timeOrigin: __sentry__timeOrigin,
now: function () {
return Date.now() - __sentry__timeOrigin;
},
};
}
// Export the performance object for perf_hooks compatibility
const performance = globalThis.performance || {
timeOrigin: __sentry__timeOrigin,
now: function () {
return Date.now() - __sentry__timeOrigin;
},
};
// Default export for CommonJS compatibility
const perf_hooks = {
performance,
};
exports.default = perf_hooks;
exports.performance = performance;
//# sourceMappingURL=perf_hooks.js.map

1
.pnpm-store/v10/files/51/04b87facecaa75d48283abc005ce651c3827e7b4217a6724310226d5a0e773533f84791ce6c3174270b33c63d4ba6375899276b7e93250df3d9bac02207769 Normal file
View File

File diff suppressed because one or more lines are too long

6
.pnpm-store/v10/files/51/06d6e1092b29f0f90eabeb539c26ff2d1304a7fc14fc367c6c50bb5f31834e97f16b17f087aaaecf9815649fbae59c2f35cc35a8b626864c2a23c09ea44126 Normal file
View File

@@ -0,0 +1,6 @@
import { getCiphers } from 'node:crypto';
let ciphers;
export default (algorithm) => {
ciphers ||= new Set(getCiphers());
return ciphers.has(algorithm);
};

2
.pnpm-store/v10/files/51/0c09935b2a25ec61cc3a20e173587cf27ad3399d02b0278e0060c4a3b1a2c9a66d2b669804577daa54b680e4d0076a5cadd2804fc6fd3ab335d212df2383c4 Normal file
View File

@@ -0,0 +1,2 @@
import { dropRight } from "./index";
export = dropRight;

131
.pnpm-store/v10/files/51/0c7001112fd5c7d5e7fa557656174b34a1fb52fc11ba173c3afa9aa05ae94ad1331e1dd8fedce9fa7653c2b4e35cd9e8c2260e6a3af738ea86687e88e6f3f9 Normal file
View File

@@ -0,0 +1,131 @@
{
"name": "uuid",
"version": "9.0.0",
"description": "RFC4122 (v1, v4, and v5) UUIDs",
"commitlint": {
"extends": [
"@commitlint/config-conventional"
]
},
"keywords": [
"uuid",
"guid",
"rfc4122"
],
"license": "MIT",
"bin": {
"uuid": "./dist/bin/uuid"
},
"sideEffects": false,
"main": "./dist/index.js",
"exports": {
".": {
"node": {
"module": "./dist/esm-node/index.js",
"require": "./dist/index.js",
"import": "./wrapper.mjs"
},
"browser": {
"import": "./dist/esm-browser/index.js",
"require": "./dist/commonjs-browser/index.js"
},
"default": "./dist/esm-browser/index.js"
},
"./package.json": "./package.json"
},
"module": "./dist/esm-node/index.js",
"browser": {
"./dist/md5.js": "./dist/md5-browser.js",
"./dist/native.js": "./dist/native-browser.js",
"./dist/rng.js": "./dist/rng-browser.js",
"./dist/sha1.js": "./dist/sha1-browser.js",
"./dist/esm-node/index.js": "./dist/esm-browser/index.js"
},
"files": [
"CHANGELOG.md",
"CONTRIBUTING.md",
"LICENSE.md",
"README.md",
"dist",
"wrapper.mjs"
],
"devDependencies": {
"@babel/cli": "7.18.10",
"@babel/core": "7.18.10",
"@babel/eslint-parser": "7.18.9",
"@babel/preset-env": "7.18.10",
"@commitlint/cli": "17.0.3",
"@commitlint/config-conventional": "17.0.3",
"bundlewatch": "0.3.3",
"eslint": "8.21.0",
"eslint-config-prettier": "8.5.0",
"eslint-config-standard": "17.0.0",
"eslint-plugin-import": "2.26.0",
"eslint-plugin-node": "11.1.0",
"eslint-plugin-prettier": "4.2.1",
"eslint-plugin-promise": "6.0.0",
"husky": "8.0.1",
"jest": "28.1.3",
"lint-staged": "13.0.3",
"npm-run-all": "4.1.5",
"optional-dev-dependency": "2.0.1",
"prettier": "2.7.1",
"random-seed": "0.3.0",
"runmd": "1.3.6",
"standard-version": "9.5.0"
},
"optionalDevDependencies": {
"@wdio/browserstack-service": "7.16.10",
"@wdio/cli": "7.16.10",
"@wdio/jasmine-framework": "7.16.6",
"@wdio/local-runner": "7.16.10",
"@wdio/spec-reporter": "7.16.9",
"@wdio/static-server-service": "7.16.6"
},
"scripts": {
"examples:browser:webpack:build": "cd examples/browser-webpack && npm install && npm run build",
"examples:browser:rollup:build": "cd examples/browser-rollup && npm install && npm run build",
"examples:node:commonjs:test": "cd examples/node-commonjs && npm install && npm test",
"examples:node:esmodules:test": "cd examples/node-esmodules && npm install && npm test",
"examples:node:jest:test": "cd examples/node-jest && npm install && npm test",
"prepare": "cd $( git rev-parse --show-toplevel ) && husky install",
"lint": "npm run eslint:check && npm run prettier:check",
"eslint:check": "eslint src/ test/ examples/ *.js",
"eslint:fix": "eslint --fix src/ test/ examples/ *.js",
"pretest": "[ -n $CI ] || npm run build",
"test": "BABEL_ENV=commonjsNode node --throw-deprecation node_modules/.bin/jest test/unit/",
"pretest:browser": "optional-dev-dependency && npm run build && npm-run-all --parallel examples:browser:**",
"test:browser": "wdio run ./wdio.conf.js",
"pretest:node": "npm run build",
"test:node": "npm-run-all --parallel examples:node:**",
"test:pack": "./scripts/testpack.sh",
"pretest:benchmark": "npm run build",
"test:benchmark": "cd examples/benchmark && npm install && npm test",
"prettier:check": "prettier --check '**/*.{js,jsx,json,md}'",
"prettier:fix": "prettier --write '**/*.{js,jsx,json,md}'",
"bundlewatch": "npm run pretest:browser && bundlewatch --config bundlewatch.config.json",
"md": "runmd --watch --output=README.md README_js.md",
"docs": "( node --version | grep -q 'v16' ) && ( npm run build && runmd --output=README.md README_js.md )",
"docs:diff": "npm run docs && git diff --quiet README.md",
"build": "./scripts/build.sh",
"prepack": "npm run build",
"release": "standard-version --no-verify"
},
"repository": {
"type": "git",
"url": "https://github.com/uuidjs/uuid.git"
},
"lint-staged": {
"*.{js,jsx,json,md}": [
"prettier --write"
],
"*.{js,jsx}": [
"eslint --fix"
]
},
"standard-version": {
"scripts": {
"postchangelog": "prettier --write CHANGELOG.md"
}
}
}

1
.pnpm-store/v10/files/51/0de06d811b7b6a82f49d5cb04af781b163e35d16ef7bb74f03d00687a720af5c0e3246f138b814aa7d180d8f3f0535c4f6566bf23df1160ae0c48c65e067af Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/elements/ReactSelect/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,IAAI,4BAA4B,EAAE,MAAM,cAAc,CAAA;AAEjG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAErE,KAAK,iBAAiB,GAAG;IACvB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,cAAc,CAAC,EAAE,GAAG,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IACrD,aAAa,CAAC,EAAE,CACd,IAAI,EAAE,MAAM,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,EAC9C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,4BAA4B,KACtC,GAAG,CAAA;IACR,QAAQ,CAAC,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAA;IAC1C,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE;QACtB,cAAc,EAAE,MAAM,CAAA;QACtB,iBAAiB,EAAE,OAAO,CAAA;QAC1B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;QACnB,YAAY,CAAC,EAAE,OAAO,CAAA;KACvB,KAAK,IAAI,CAAA;IACV,WAAW,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAA;IAC3C,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAA;IACtC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAKD,OAAO,QAAQ,2CAA2C,CAAC;IACzD,UAAiB,KAAK,CAAC,MAAM,EAAE,OAAO,SAAS,OAAO,EAAE,KAAK,SAAS,SAAS,CAAC,MAAM,CAAC;QACrF,WAAW,CAAC,EAAE,iBAAiB,CAAA;KAChC;CACF;AAKD,OAAO,QAAQ,oCAAoC,CAAC;IAClD,UAAiB,uBAAuB,CACtC,MAAM,EACN,OAAO,SAAS,OAAO,EACvB,KAAK,SAAS,SAAS,CAAC,MAAM,CAAC,CAC/B,SAAQ,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC;QAC3C,WAAW,CAAC,EAAE,iBAAiB,GAAG,4BAA4B,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,CAAA;KACvF;CACF;AAED,MAAM,MAAM,MAAM,CAAC,MAAM,GAAG,OAAO,IAAI;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IAEtB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE;QACX,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAA;KAC7B,CAAA;IACD,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EACT,CAAC,CACC,EACE,SAAS,EACT,IAAI,EACJ,KAAK,EACL,KAAK,GACN,EAAE;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EACrE,MAAM,EAAE,MAAM,KACX,OAAO,CAAC,GACb,SAAS,CAAA;IACb,cAAc,CAAC,EAAE,4BAA4B,CAC3C,MAAM,EACN,OAAO,EACP,SAAS,CAAC,MAAM,CAAC,CAClB,CAAC,gBAAgB,CAAC,CAAA;IACnB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,qFAAqF;IACrF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gEAAgE;IAChE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gBAAgB,CAAC,EAAE,GAAG,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAA;IAC1D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAA;IAC7C,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAA;IACvB,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAA;IACjC,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,CAAA;IACjC,WAAW,CAAC,EAAE,aAAa,GAAG,MAAM,CAAA;IACpC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1B,CAAA"}

1
.pnpm-store/v10/files/51/0ecba1999331b79a9c823c27f3fdda193b6f7f8249bc9756fb4af558fa2dd19f5034d0fca486269139f8d1bc9009c38003410b153514c48f0779f2397e1c5a Normal file
View File

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

60
.pnpm-store/v10/files/51/10489e4355871d45a2d32651cf8a8bd21d93a5b8020c83310fcd2f479c4d730f64a37158b85ff35e4655c9aa2f8e4168b5a7f6636d586e23b49782fad97f50 Normal file
View File

@@ -0,0 +1,60 @@
import type { SavepointSQL, SQL, TransactionSQL } from 'bun';
import { type Cache } from "../cache/core/index.cjs";
import type { WithCacheConfig } from "../cache/core/types.cjs";
import { entityKind } from "../entity.cjs";
import type { Logger } from "../logger.cjs";
import type { PgDialect } from "../pg-core/dialect.cjs";
import { PgTransaction } from "../pg-core/index.cjs";
import type { SelectedFieldsOrdered } from "../pg-core/query-builders/select.types.cjs";
import type { PgQueryResultHKT, PgTransactionConfig, PreparedQueryConfig } from "../pg-core/session.cjs";
import { PgPreparedQuery, PgSession } from "../pg-core/session.cjs";
import type { RelationalSchemaConfig, TablesRelationalConfig } from "../relations.cjs";
import { type Query } from "../sql/sql.cjs";
import { type Assume } from "../utils.cjs";
export declare class BunSQLPreparedQuery<T extends PreparedQueryConfig> extends PgPreparedQuery<T> {
private client;
private queryString;
private params;
private logger;
private fields;
private _isResponseInArrayMode;
private customResultMapper?;
static readonly [entityKind]: string;
constructor(client: SQL, queryString: string, params: unknown[], logger: Logger, cache: Cache, queryMetadata: {
type: 'select' | 'update' | 'delete' | 'insert';
tables: string[];
} | undefined, cacheConfig: WithCacheConfig | undefined, fields: SelectedFieldsOrdered | undefined, _isResponseInArrayMode: boolean, customResultMapper?: ((rows: unknown[][]) => T["execute"]) | undefined);
execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
all(placeholderValues?: Record<string, unknown> | undefined): Promise<T['all']>;
}
export interface BunSQLSessionOptions {
logger?: Logger;
cache?: Cache;
}
export declare class BunSQLSession<TSQL extends SQL, TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgSession<BunSQLQueryResultHKT, TFullSchema, TSchema> {
client: TSQL;
private schema;
static readonly [entityKind]: string;
logger: Logger;
private cache;
constructor(client: TSQL, dialect: PgDialect, schema: RelationalSchemaConfig<TSchema> | undefined,
/** @internal */
options?: BunSQLSessionOptions);
prepareQuery<T extends PreparedQueryConfig = PreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, name: string | undefined, isResponseInArrayMode: boolean, customResultMapper?: (rows: unknown[][]) => T['execute'], queryMetadata?: {
type: 'select' | 'update' | 'delete' | 'insert';
tables: string[];
}, cacheConfig?: WithCacheConfig): PgPreparedQuery<T>;
query(query: string, params: unknown[]): Promise<any>;
queryObjects(query: string, params: unknown[]): Promise<any>;
transaction<T>(transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>, config?: PgTransactionConfig): Promise<T>;
}
export declare class BunSQLTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends PgTransaction<BunSQLQueryResultHKT, TFullSchema, TSchema> {
static readonly [entityKind]: string;
constructor(dialect: PgDialect,
/** @internal */
session: BunSQLSession<TransactionSQL | SavepointSQL, TFullSchema, TSchema>, schema: RelationalSchemaConfig<TSchema> | undefined, nestedIndex?: number);
transaction<T>(transaction: (tx: BunSQLTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
}
export interface BunSQLQueryResultHKT extends PgQueryResultHKT {
type: Assume<this['row'], Record<string, any>[]>;
}

35
.pnpm-store/v10/files/51/153536a1231f15bb3e3c29d6b0433fe3d4eaf542d97ae14cecde5ec9d96b95f88b4732671cddb825100ba405340987aca41b4706dd5d030d50d443f2243109 Normal file
View File

@@ -0,0 +1,35 @@
"use strict";
/*
* Copyright The OpenTelemetry Authors
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.createNoopDiagLogger = void 0;
function noopLogFunction() { }
/**
* Returns a No-Op Diagnostic logger where all messages do nothing.
* @implements {@link DiagLogger}
* @returns {DiagLogger}
*/
function createNoopDiagLogger() {
return {
verbose: noopLogFunction,
debug: noopLogFunction,
info: noopLogFunction,
warn: noopLogFunction,
error: noopLogFunction,
};
}
exports.createNoopDiagLogger = createNoopDiagLogger;
//# sourceMappingURL=noopLogger.js.map

17
.pnpm-store/v10/files/51/153cd0b31693f7361f729e46a200cc5b0ad5509a0e6c5fe198dc753c390e07d22349d48d37348cae13679ce442a4a46e2b75e45da358474c967e9d61aad923 Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var types_exports = {};
module.exports = __toCommonJS(types_exports);
//# sourceMappingURL=types.cjs.map

1
.pnpm-store/v10/files/51/15a11624ad1cacb3548c626703ff7255eb07b33da9e449b7a198094ee4b647bec6e8be6dcfe08f8766ca8f51d0d59bcb85cc3a2bdf3070c5d4077cdd5b685b Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"move-up-left.js","sources":["../../../src/icons/move-up-left.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name MoveUpLeft\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNNSAxMVY1SDExIiAvPgogIDxwYXRoIGQ9Ik01IDVMMTkgMTkiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/move-up-left\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 MoveUpLeft = createLucideIcon('MoveUpLeft', [\n ['path', { d: 'M5 11V5H11', key: '3q78g9' }],\n ['path', { d: 'M5 5L19 19', key: '5zm2fv' }],\n]);\n\nexport default MoveUpLeft;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAa,iBAAiB,YAAc,CAAA,CAAA,CAAA;AAAA,CAAA,CAChD,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;AAC7C,CAAC,CAAA,CAAA;;"}

29
.pnpm-store/v10/files/51/1925ba3db334fac93e0905cb9e4528303557a917484857423fc83c4b64e88ab870929d297e326b88470b0476b5724236d25b7468d94dc4bfc7d28abbf5c28e Normal file
View File

@@ -0,0 +1,29 @@
/**
* @license lucide-react v0.441.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 MemoryStick = createLucideIcon("MemoryStick", [
["path", { d: "M6 19v-3", key: "1nvgqn" }],
["path", { d: "M10 19v-3", key: "iu8nkm" }],
["path", { d: "M14 19v-3", key: "kcehxu" }],
["path", { d: "M18 19v-3", key: "1vh91z" }],
["path", { d: "M8 11V9", key: "63erz4" }],
["path", { d: "M16 11V9", key: "fru6f3" }],
["path", { d: "M12 11V9", key: "ha00sb" }],
["path", { d: "M2 15h20", key: "16ne18" }],
[
"path",
{
d: "M2 7a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1.1a2 2 0 0 0 0 3.837V17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-5.1a2 2 0 0 0 0-3.837Z",
key: "lhddv3"
}
]
]);
export { MemoryStick as default };
//# sourceMappingURL=memory-stick.js.map

3
.pnpm-store/v10/files/51/19994ed74cfa8c87c4bcd74e652d2a17c8ffabc6a7b26ef4d92c3bfc6b98007c25225cf86b5f111b5e5f4fe39165e0759adb7a99858d5ce468f15066212b0f Normal file
View File

@@ -0,0 +1,3 @@
import type { CreateJSONQueryArgs } from '../../types.js';
export declare const createJSONQuery: ({ column, operator, pathSegments, value }: CreateJSONQueryArgs) => string;
//# sourceMappingURL=index.d.ts.map

1
.pnpm-store/v10/files/51/1a37d1e0f57ef9e494ffaaa98da6b55e354d6a5ffdfb66c68fb71c8cd3931868bc8a1f182c1ff9f794b582723a2c6bba4637240d4685c3b5b2d78c05210149 Normal file
View File

@@ -0,0 +1 @@
Prism.languages.livescript={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?\*\//,lookbehind:!0},{pattern:/(^|[^\\])#.*/,lookbehind:!0}],"interpolated-string":{pattern:/(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,lookbehind:!0,greedy:!0,inside:{variable:{pattern:/(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,lookbehind:!0},interpolation:{pattern:/(^|[^\\])#\{[^}]+\}/m,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^#\{|\}$/,alias:"variable"}}},string:/[\s\S]+/}},string:[{pattern:/('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,greedy:!0},{pattern:/<\[[\s\S]*?\]>/,greedy:!0},/\\[^\s,;\])}]+/],regex:[{pattern:/\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,greedy:!0,inside:{comment:{pattern:/(^|[^\\])#.*/,lookbehind:!0}}},{pattern:/\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,greedy:!0}],keyword:{pattern:/(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,lookbehind:!0},"keyword-operator":{pattern:/(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,lookbehind:!0,alias:"operator"},boolean:{pattern:/(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,lookbehind:!0},argument:{pattern:/(^|(?!\.&\.)[^&])&(?!&)\d*/m,lookbehind:!0,alias:"variable"},number:/\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,identifier:/[a-z_](?:-?[a-z]|[\d_])*/i,operator:[{pattern:/( )\.(?= )/,lookbehind:!0},/\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/],punctuation:/[(){}\[\]|.,:;`]/},Prism.languages.livescript["interpolated-string"].inside.interpolation.inside.rest=Prism.languages.livescript;

8
.pnpm-store/v10/files/51/1d099a7ae5866379a1e7ef54c85457e11d722cfd222e2f046b9d24d6ac40f3f89fcc40d4e4c14c6d1d40dd48f6f3e7dc260b71668ebe85ebd4d527a562b8c4 Normal file
View File

@@ -0,0 +1,8 @@
"use strict";
exports.eachWeekendOfYearWithOptions = void 0;
var _index = require("../eachWeekendOfYear.cjs");
var _index2 = require("./_lib/convertToFP.cjs"); // This file is generated automatically by `scripts/build/fp.ts`. Please, don't change it.
const eachWeekendOfYearWithOptions = (exports.eachWeekendOfYearWithOptions = (0,
_index2.convertToFP)(_index.eachWeekendOfYear, 2));

96
.pnpm-store/v10/files/51/1e6b8e273dd8d60eb170ff0b92c9b19c181ddd9b628b4fe6cf1d9b6d28b5c2aed75d5dfea1e329fe4d4df643884c7467d1cedd99345851c143ae29dedc2449 Normal file
View File

@@ -0,0 +1,96 @@
import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
import _toConsumableArray from '@babel/runtime/helpers/esm/toConsumableArray';
import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
import { useMemo, useCallback } from 'react';
import { H as cleanValue, D as valueTernary } from './index-641ee5b8.esm.js';
import { g as getOptionValue, b as getOptionLabel } from './Select-aab027f3.esm.js';
var _excluded = ["allowCreateWhileLoading", "createOptionPosition", "formatCreateLabel", "isValidNewOption", "getNewOptionData", "onCreateOption", "options", "onChange"];
var compareOption = function compareOption() {
var inputValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
var option = arguments.length > 1 ? arguments[1] : undefined;
var accessors = arguments.length > 2 ? arguments[2] : undefined;
var candidate = String(inputValue).toLowerCase();
var optionValue = String(accessors.getOptionValue(option)).toLowerCase();
var optionLabel = String(accessors.getOptionLabel(option)).toLowerCase();
return optionValue === candidate || optionLabel === candidate;
};
var builtins = {
formatCreateLabel: function formatCreateLabel(inputValue) {
return "Create \"".concat(inputValue, "\"");
},
isValidNewOption: function isValidNewOption(inputValue, selectValue, selectOptions, accessors) {
return !(!inputValue || selectValue.some(function (option) {
return compareOption(inputValue, option, accessors);
}) || selectOptions.some(function (option) {
return compareOption(inputValue, option, accessors);
}));
},
getNewOptionData: function getNewOptionData(inputValue, optionLabel) {
return {
label: optionLabel,
value: inputValue,
__isNew__: true
};
}
};
function useCreatable(_ref) {
var _ref$allowCreateWhile = _ref.allowCreateWhileLoading,
allowCreateWhileLoading = _ref$allowCreateWhile === void 0 ? false : _ref$allowCreateWhile,
_ref$createOptionPosi = _ref.createOptionPosition,
createOptionPosition = _ref$createOptionPosi === void 0 ? 'last' : _ref$createOptionPosi,
_ref$formatCreateLabe = _ref.formatCreateLabel,
formatCreateLabel = _ref$formatCreateLabe === void 0 ? builtins.formatCreateLabel : _ref$formatCreateLabe,
_ref$isValidNewOption = _ref.isValidNewOption,
isValidNewOption = _ref$isValidNewOption === void 0 ? builtins.isValidNewOption : _ref$isValidNewOption,
_ref$getNewOptionData = _ref.getNewOptionData,
getNewOptionData = _ref$getNewOptionData === void 0 ? builtins.getNewOptionData : _ref$getNewOptionData,
onCreateOption = _ref.onCreateOption,
_ref$options = _ref.options,
propsOptions = _ref$options === void 0 ? [] : _ref$options,
propsOnChange = _ref.onChange,
restSelectProps = _objectWithoutProperties(_ref, _excluded);
var _restSelectProps$getO = restSelectProps.getOptionValue,
getOptionValue$1 = _restSelectProps$getO === void 0 ? getOptionValue : _restSelectProps$getO,
_restSelectProps$getO2 = restSelectProps.getOptionLabel,
getOptionLabel$1 = _restSelectProps$getO2 === void 0 ? getOptionLabel : _restSelectProps$getO2,
inputValue = restSelectProps.inputValue,
isLoading = restSelectProps.isLoading,
isMulti = restSelectProps.isMulti,
value = restSelectProps.value,
name = restSelectProps.name;
var newOption = useMemo(function () {
return isValidNewOption(inputValue, cleanValue(value), propsOptions, {
getOptionValue: getOptionValue$1,
getOptionLabel: getOptionLabel$1
}) ? getNewOptionData(inputValue, formatCreateLabel(inputValue)) : undefined;
}, [formatCreateLabel, getNewOptionData, getOptionLabel$1, getOptionValue$1, inputValue, isValidNewOption, propsOptions, value]);
var options = useMemo(function () {
return (allowCreateWhileLoading || !isLoading) && newOption ? createOptionPosition === 'first' ? [newOption].concat(_toConsumableArray(propsOptions)) : [].concat(_toConsumableArray(propsOptions), [newOption]) : propsOptions;
}, [allowCreateWhileLoading, createOptionPosition, isLoading, newOption, propsOptions]);
var onChange = useCallback(function (newValue, actionMeta) {
if (actionMeta.action !== 'select-option') {
return propsOnChange(newValue, actionMeta);
}
var valueArray = Array.isArray(newValue) ? newValue : [newValue];
if (valueArray[valueArray.length - 1] === newOption) {
if (onCreateOption) onCreateOption(inputValue);else {
var newOptionData = getNewOptionData(inputValue, inputValue);
var newActionMeta = {
action: 'create-option',
name: name,
option: newOptionData
};
propsOnChange(valueTernary(isMulti, [].concat(_toConsumableArray(cleanValue(value)), [newOptionData]), newOptionData), newActionMeta);
}
return;
}
propsOnChange(newValue, actionMeta);
}, [getNewOptionData, inputValue, isMulti, name, newOption, onCreateOption, propsOnChange, value]);
return _objectSpread(_objectSpread({}, restSelectProps), {}, {
options: options,
onChange: onChange
});
}
export { useCreatable as u };

10
.pnpm-store/v10/files/51/2021faeb2ad2c803f30e2f9c35871856401a7dbca8912c04a6969801ed78ffbf3a9d6065db835b1f115d0203546ac6861beaedcc34623cee68f95e9426e86c Normal file
View File

@@ -0,0 +1,10 @@
"use strict";
exports.getWeeksInMonth = void 0;
var _index = require("../getWeeksInMonth.js");
var _index2 = require("./_lib/convertToFP.js"); // This file is generated automatically by `scripts/build/fp.ts`. Please, don't change it.
const getWeeksInMonth = (exports.getWeeksInMonth = (0, _index2.convertToFP)(
_index.getWeeksInMonth,
1,
));

3
.pnpm-store/v10/files/51/2268b6ec62337d0da3c368a9e52cd34b17f2470bd5ae86afca39c4b99074e2f813a4d79e164743fbd466a6968129745fd4f7bfe416ba26c759cde84423c441 Normal file
View File

@@ -0,0 +1,3 @@
import { type ZodErrorMap } from "../ZodError.js";
declare const errorMap: ZodErrorMap;
export default errorMap;

57
.pnpm-store/v10/files/51/236d0157ab037451e16f2db17655e1261dd158e9e0835da2eff1e808448b5da2c94d4f09cdf21a84cb68e1a9a2e81c29b1b39d9ce3607c2ead2d08f2ab8dda Normal file
View File

@@ -0,0 +1,57 @@
{
"name": "loader-runner",
"version": "4.3.1",
"description": "Runs (webpack) loaders",
"keywords": ["webpack", "loader"],
"homepage": "https://github.com/webpack/loader-runner#readme",
"bugs": {
"url": "https://github.com/webpack/loader-runner/issues"
},
"repository": {
"type": "git",
"url": "git+https://github.com/webpack/loader-runner.git"
},
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/webpack"
},
"license": "MIT",
"author": "Tobias Koppers @sokra",
"main": "lib/LoaderRunner.js",
"files": ["lib/", "bin/", "hot/", "web_modules/", "schemas/"],
"scripts": {
"lint": "npm run lint:code && npm run fmt:check",
"lint:code": "eslint --cache .",
"fmt": "npm run fmt:base -- --log-level warn --write",
"fmt:check": "npm run fmt:base -- --check",
"fmt:base": "prettier --cache --ignore-unknown .",
"fix": "npm run fix:code && npm run fmt",
"fix:code": "npm run lint:code -- --fix",
"pretest": "npm run lint",
"test": "npm run test:basic",
"test:basic": "mocha --reporter spec",
"test:cover": "nyc --reporter=lcov npm run test:basic"
},
"devDependencies": {
"@eslint/js": "^9.28.0",
"@eslint/markdown": "^7.1.0",
"@stylistic/eslint-plugin": "^5.2.3",
"globals": "^16.2.0",
"eslint": "^9.28.0",
"eslint-config-webpack": "^4.6.1",
"eslint-config-prettier": "^10.1.5",
"eslint-plugin-import": "^2.31.0",
"eslint-plugin-jest": "^28.12.0",
"eslint-plugin-jsdoc": "^54.1.1",
"eslint-plugin-n": "^17.19.0",
"eslint-plugin-prettier": "^5.4.1",
"eslint-plugin-unicorn": "^60.0.0",
"prettier": "^3.5.3",
"nyc": "^14.1.1",
"mocha": "^3.2.0",
"should": "^8.0.2"
},
"engines": {
"node": ">=6.11.5"
}
}

47
.pnpm-store/v10/files/51/23f0f1840152fd55b94fc6c778be3276475c1a60cf1c9325ce92e7d4a290003ef896047f5993b90709128816ee4806e775d5ea6f44ae5359e6ef4cd6d2654d Normal file
View File

@@ -0,0 +1,47 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var ReactJSXRuntimeDev = require('react/jsx-dev-runtime');
var emotionElement = require('../../dist/emotion-element-4787f564.browser.development.cjs.js');
require('react');
require('@emotion/cache');
require('@babel/runtime/helpers/extends');
require('@emotion/weak-memoize');
require('../../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.cjs.js');
require('hoist-non-react-statics');
require('@emotion/utils');
require('@emotion/serialize');
require('@emotion/use-insertion-effect-with-fallbacks');
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n["default"] = e;
return Object.freeze(n);
}
var ReactJSXRuntimeDev__namespace = /*#__PURE__*/_interopNamespace(ReactJSXRuntimeDev);
var Fragment = ReactJSXRuntimeDev__namespace.Fragment;
var jsxDEV = function jsxDEV(type, props, key, isStaticChildren, source, self) {
if (!emotionElement.hasOwn.call(props, 'css')) {
return ReactJSXRuntimeDev__namespace.jsxDEV(type, props, key, isStaticChildren, source, self);
}
return ReactJSXRuntimeDev__namespace.jsxDEV(emotionElement.Emotion, emotionElement.createEmotionProps(type, props), key, isStaticChildren, source, self);
};
exports.Fragment = Fragment;
exports.jsxDEV = jsxDEV;

15
.pnpm-store/v10/files/51/24d1d1abb7f9f997ad1a9e6730ce3efb3f2d9a1422ee8648465d393416876cc8cd7be5372052a768acdb1e2b00944d0c132e1087a56615af82fa97b2d86576 Normal file
View File

@@ -0,0 +1,15 @@
/**
* CanonicalizeTimeZoneName ( timeZone )
* https://tc39.es/ecma402/#sec-canonicalizetimezonename
*
* Extended to support UTC offset time zones per ECMA-402 PR #788 (ES2026).
* Returns the canonical and case-regularized form of a timezone identifier.
*
* @param tz - The timezone identifier to canonicalize
* @param implDetails - Implementation details containing timezone data
* @returns The canonical timezone identifier
*/
export declare function CanonicalizeTimeZoneName(tz: string, { zoneNames, uppercaseLinks }: {
zoneNames: readonly string[];
uppercaseLinks: Record<string, string>;
}): string;

1
.pnpm-store/v10/files/51/282fa19475dd926d9239b18c6e730d926b0c44e1313ba2abe2d012b198b20a2e1f217f5446f773641cc7259942861ec38a95d9ce52dcd18e21025aa73fe5c3 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"chevrons-left-right.js","sources":["../../../src/icons/chevrons-left-right.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name ChevronsLeftRight\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJtOSA3LTUgNSA1IDUiIC8+CiAgPHBhdGggZD0ibTE1IDcgNSA1LTUgNSIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/chevrons-left-right\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 ChevronsLeftRight = createLucideIcon('ChevronsLeftRight', [\n ['path', { d: 'm9 7-5 5 5 5', key: 'j5w590' }],\n ['path', { d: 'm15 7 5 5-5 5', key: '1bl6da' }],\n]);\n\nexport default ChevronsLeftRight;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAoB,iBAAiB,mBAAqB,CAAA,CAAA,CAAA;AAAA,CAAA,CAC9D,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,CAAA;AAAA,CAAA,CAC7C,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;AAChD,CAAC,CAAA,CAAA;;"}

356
.pnpm-store/v10/files/51/288c7db5ca7a6fdb8cafae48a5a7a5aecf24e4b506dc4e6fcfda105e168a138ea5378f9d711b25c8700e320786a1ab4268389d10f0c6e53579a942b2d19797 Normal file
View File

@@ -0,0 +1,356 @@
import * as core from "../core/index.cjs";
import { util } from "../core/index.cjs";
type SomeType = core.SomeType;
export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
clone(def?: Internals["def"], params?: {
parent: boolean;
}): this;
register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace<R["_meta"], this>?] : [core.$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"output", core.output<this> & core.$brand<T>>>;
def: Internals["def"];
parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
}
interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
}
export declare const ZodMiniType: core.$constructor<ZodMiniType>;
export interface _ZodMiniString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodMiniType<T>, core.$ZodString<T["input"]> {
_zod: T;
}
export interface ZodMiniString<Input = unknown> extends _ZodMiniString<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {
}
export declare const ZodMiniString: core.$constructor<ZodMiniString>;
export declare function string(params?: string | core.$ZodStringParams): ZodMiniString<string>;
export interface ZodMiniStringFormat<Format extends string = string> extends _ZodMiniString<core.$ZodStringFormatInternals<Format>>, core.$ZodStringFormat<Format> {
}
export declare const ZodMiniStringFormat: core.$constructor<ZodMiniStringFormat>;
export interface ZodMiniEmail extends _ZodMiniString<core.$ZodEmailInternals> {
}
export declare const ZodMiniEmail: core.$constructor<ZodMiniEmail>;
export declare function email(params?: string | core.$ZodEmailParams): ZodMiniEmail;
export interface ZodMiniGUID extends _ZodMiniString<core.$ZodGUIDInternals> {
}
export declare const ZodMiniGUID: core.$constructor<ZodMiniGUID>;
export declare function guid(params?: string | core.$ZodGUIDParams): ZodMiniGUID;
export interface ZodMiniUUID extends _ZodMiniString<core.$ZodUUIDInternals> {
}
export declare const ZodMiniUUID: core.$constructor<ZodMiniUUID>;
export declare function uuid(params?: string | core.$ZodUUIDParams): ZodMiniUUID;
export declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodMiniUUID;
export declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodMiniUUID;
export declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodMiniUUID;
export interface ZodMiniURL extends _ZodMiniString<core.$ZodURLInternals> {
}
export declare const ZodMiniURL: core.$constructor<ZodMiniURL>;
export declare function url(params?: string | core.$ZodURLParams): ZodMiniURL;
export interface ZodMiniEmoji extends _ZodMiniString<core.$ZodEmojiInternals> {
}
export declare const ZodMiniEmoji: core.$constructor<ZodMiniEmoji>;
export declare function emoji(params?: string | core.$ZodEmojiParams): ZodMiniEmoji;
export interface ZodMiniNanoID extends _ZodMiniString<core.$ZodNanoIDInternals> {
}
export declare const ZodMiniNanoID: core.$constructor<ZodMiniNanoID>;
export declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodMiniNanoID;
export interface ZodMiniCUID extends _ZodMiniString<core.$ZodCUIDInternals> {
}
export declare const ZodMiniCUID: core.$constructor<ZodMiniCUID>;
export declare function cuid(params?: string | core.$ZodCUIDParams): ZodMiniCUID;
export interface ZodMiniCUID2 extends _ZodMiniString<core.$ZodCUID2Internals> {
}
export declare const ZodMiniCUID2: core.$constructor<ZodMiniCUID2>;
export declare function cuid2(params?: string | core.$ZodCUID2Params): ZodMiniCUID2;
export interface ZodMiniULID extends _ZodMiniString<core.$ZodULIDInternals> {
}
export declare const ZodMiniULID: core.$constructor<ZodMiniULID>;
export declare function ulid(params?: string | core.$ZodULIDParams): ZodMiniULID;
export interface ZodMiniXID extends _ZodMiniString<core.$ZodXIDInternals> {
}
export declare const ZodMiniXID: core.$constructor<ZodMiniXID>;
export declare function xid(params?: string | core.$ZodXIDParams): ZodMiniXID;
export interface ZodMiniKSUID extends _ZodMiniString<core.$ZodKSUIDInternals> {
}
export declare const ZodMiniKSUID: core.$constructor<ZodMiniKSUID>;
export declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodMiniKSUID;
export interface ZodMiniIPv4 extends _ZodMiniString<core.$ZodIPv4Internals> {
}
export declare const ZodMiniIPv4: core.$constructor<ZodMiniIPv4>;
export declare function ipv4(params?: string | core.$ZodIPv4Params): ZodMiniIPv4;
export interface ZodMiniIPv6 extends _ZodMiniString<core.$ZodIPv6Internals> {
}
export declare const ZodMiniIPv6: core.$constructor<ZodMiniIPv6>;
export declare function ipv6(params?: string | core.$ZodIPv6Params): ZodMiniIPv6;
export interface ZodMiniCIDRv4 extends _ZodMiniString<core.$ZodCIDRv4Internals> {
}
export declare const ZodMiniCIDRv4: core.$constructor<ZodMiniCIDRv4>;
export declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodMiniCIDRv4;
export interface ZodMiniCIDRv6 extends _ZodMiniString<core.$ZodCIDRv6Internals> {
}
export declare const ZodMiniCIDRv6: core.$constructor<ZodMiniCIDRv6>;
export declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodMiniCIDRv6;
export interface ZodMiniBase64 extends _ZodMiniString<core.$ZodBase64Internals> {
}
export declare const ZodMiniBase64: core.$constructor<ZodMiniBase64>;
export declare function base64(params?: string | core.$ZodBase64Params): ZodMiniBase64;
export interface ZodMiniBase64URL extends _ZodMiniString<core.$ZodBase64URLInternals> {
}
export declare const ZodMiniBase64URL: core.$constructor<ZodMiniBase64URL>;
export declare function base64url(params?: string | core.$ZodBase64URLParams): ZodMiniBase64URL;
export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
}
export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
}
export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
export declare function jwt(params?: string | core.$ZodJWTParams): ZodMiniJWT;
export interface ZodMiniCustomStringFormat<Format extends string = string> extends ZodMiniStringFormat<Format>, core.$ZodCustomStringFormat<Format> {
_zod: core.$ZodCustomStringFormatInternals<Format>;
}
export declare const ZodMiniCustomStringFormat: core.$constructor<ZodMiniCustomStringFormat>;
export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<Format>;
interface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>> extends _ZodMiniType<T>, core.$ZodNumber<T["input"]> {
_zod: T;
}
export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$ZodNumberInternals<Input>>, core.$ZodNumber<Input> {
}
export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
}
export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
}
export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
export declare function boolean(params?: string | core.$ZodBooleanParams): ZodMiniBoolean<boolean>;
export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigIntInternals<T>>, core.$ZodBigInt<T> {
}
export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
}
export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
}
export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
export declare function symbol(params?: string | core.$ZodSymbolParams): ZodMiniSymbol;
export interface ZodMiniUndefined extends _ZodMiniType<core.$ZodUndefinedInternals> {
}
export declare const ZodMiniUndefined: core.$constructor<ZodMiniUndefined>;
declare function _undefined(params?: string | core.$ZodUndefinedParams): ZodMiniUndefined;
export { _undefined as undefined };
export interface ZodMiniNull extends _ZodMiniType<core.$ZodNullInternals> {
}
export declare const ZodMiniNull: core.$constructor<ZodMiniNull>;
declare function _null(params?: string | core.$ZodNullParams): ZodMiniNull;
export { _null as null };
export interface ZodMiniAny extends _ZodMiniType<core.$ZodAnyInternals> {
}
export declare const ZodMiniAny: core.$constructor<ZodMiniAny>;
export declare function any(): ZodMiniAny;
export interface ZodMiniUnknown extends _ZodMiniType<core.$ZodUnknownInternals> {
}
export declare const ZodMiniUnknown: core.$constructor<ZodMiniUnknown>;
export declare function unknown(): ZodMiniUnknown;
export interface ZodMiniNever extends _ZodMiniType<core.$ZodNeverInternals> {
}
export declare const ZodMiniNever: core.$constructor<ZodMiniNever>;
export declare function never(params?: string | core.$ZodNeverParams): ZodMiniNever;
export interface ZodMiniVoid extends _ZodMiniType<core.$ZodVoidInternals> {
}
export declare const ZodMiniVoid: core.$constructor<ZodMiniVoid>;
declare function _void(params?: string | core.$ZodVoidParams): ZodMiniVoid;
export { _void as void };
export interface ZodMiniDate<T = unknown> extends _ZodMiniType<core.$ZodDateInternals<T>> {
}
export declare const ZodMiniDate: core.$constructor<ZodMiniDate>;
export declare function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date>;
export interface ZodMiniArray<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
}
export declare const ZodMiniArray: core.$constructor<ZodMiniArray>;
export declare function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;
export declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<Exclude<keyof T["shape"], symbol>>;
export interface ZodMiniObject<
/** @ts-ignore Cast variance */
out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$strip> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
shape: Shape;
}
export declare const ZodMiniObject: core.$constructor<ZodMiniObject>;
export declare function object<T extends core.$ZodLooseShape = Record<never, SomeType>>(shape?: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$strip>;
export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$strict>;
export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$loose>;
export declare function extend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: U): ZodMiniObject<util.Extend<T["shape"], U>, T["_zod"]["config"]>;
/** @deprecated Identical to `z.extend(A, B)` */
export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
export declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]>;
export declare function omit<T extends ZodMiniObject, const M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]>;
export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
[k in keyof T["shape"]]: ZodMiniOptional<T["shape"][k]>;
}, T["_zod"]["config"]>;
export declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M): ZodMiniObject<{
[k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
}, T["_zod"]["config"]>;
export type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{
[k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;
} & {
[k in keyof Shape as k extends Keys ? never : k]: Shape[k];
}>;
export declare function required<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
[k in keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;
}, T["_zod"]["config"]>;
export declare function required<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M): ZodMiniObject<util.Extend<T["shape"], {
[k in keyof M & keyof T["shape"]]: ZodMiniNonOptional<T["shape"][k]>;
}>, T["_zod"]["config"]>;
export declare function catchall<T extends ZodMiniObject, U extends SomeType>(inst: T, catchall: U): ZodMiniObject<T["shape"], core.$catchall<U>>;
export interface ZodMiniUnion<T extends readonly SomeType[] = readonly core.$ZodType[]> extends _ZodMiniType<core.$ZodUnionInternals<T>> {
}
export declare const ZodMiniUnion: core.$constructor<ZodMiniUnion>;
export declare function union<const T extends readonly SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodMiniUnion<T>;
export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] = readonly core.$ZodType[]> extends ZodMiniUnion<Options> {
_zod: core.$ZodDiscriminatedUnionInternals<Options>;
}
export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]]>(discriminator: string, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types>;
export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
}
export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;
export declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodMiniIntersection<T, U>;
export interface ZodMiniTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends SomeType | null = core.$ZodType | null> extends _ZodMiniType<core.$ZodTupleInternals<T, Rest>> {
}
export declare const ZodMiniTuple: core.$constructor<ZodMiniTuple>;
export declare function tuple<const T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, null>;
export declare function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, Rest>;
export declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodMiniTuple<[], null>;
export interface ZodMiniRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodRecordInternals<Key, Value>> {
}
export declare const ZodMiniRecord: core.$constructor<ZodMiniRecord>;
export declare function record<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key, Value>;
export declare function partialRecord<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key & core.$partial, Value>;
export interface ZodMiniMap<Key extends SomeType = core.$ZodType, Value extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodMapInternals<Key, Value>> {
}
export declare const ZodMiniMap: core.$constructor<ZodMiniMap>;
export declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMiniMap<Key, Value>;
export interface ZodMiniSet<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodSetInternals<T>> {
}
export declare const ZodMiniSet: core.$constructor<ZodMiniSet>;
export declare function set<Value extends SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodMiniSet<Value>;
export interface ZodMiniEnum<T extends util.EnumLike = util.EnumLike> extends _ZodMiniType<core.$ZodEnumInternals<T>> {
}
export declare const ZodMiniEnum: core.$constructor<ZodMiniEnum>;
declare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<util.ToEnum<T[number]>>;
declare function _enum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;
export { _enum as enum };
/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
*
* ```ts
* enum Colors { red, green, blue }
* z.enum(Colors);
* ```
*/
export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;
export interface ZodMiniLiteral<T extends util.Literal = util.Literal> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {
}
export declare const ZodMiniLiteral: core.$constructor<ZodMiniLiteral>;
export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;
export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T>;
export interface ZodMiniFile extends _ZodMiniType<core.$ZodFileInternals> {
}
export declare const ZodMiniFile: core.$constructor<ZodMiniFile>;
export declare function file(params?: string | core.$ZodFileParams): ZodMiniFile;
export interface ZodMiniTransform<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodTransformInternals<O, I>> {
}
export declare const ZodMiniTransform: core.$constructor<ZodMiniTransform>;
export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodMiniTransform<Awaited<O>, I>;
export interface ZodMiniOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<T> {
}
export declare const ZodMiniOptional: core.$constructor<ZodMiniOptional>;
export declare function optional<T extends SomeType>(innerType: T): ZodMiniOptional<T>;
export interface ZodMiniNullable<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNullableInternals<T>> {
}
export declare const ZodMiniNullable: core.$constructor<ZodMiniNullable>;
export declare function nullable<T extends SomeType>(innerType: T): ZodMiniNullable<T>;
export declare function nullish<T extends SomeType>(innerType: T): ZodMiniOptional<ZodMiniNullable<T>>;
export interface ZodMiniDefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodDefaultInternals<T>> {
}
export declare const ZodMiniDefault: core.$constructor<ZodMiniDefault>;
export declare function _default<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodMiniDefault<T>;
export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {
}
export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {
}
export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;
export declare function nonoptional<T extends SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodMiniNonOptional<T>;
export interface ZodMiniSuccess<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodSuccessInternals<T>> {
}
export declare const ZodMiniSuccess: core.$constructor<ZodMiniSuccess>;
export declare function success<T extends SomeType>(innerType: T): ZodMiniSuccess<T>;
export interface ZodMiniCatch<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodCatchInternals<T>> {
}
export declare const ZodMiniCatch: core.$constructor<ZodMiniCatch>;
declare function _catch<T extends SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodMiniCatch<T>;
export { _catch as catch };
export interface ZodMiniNaN extends _ZodMiniType<core.$ZodNaNInternals> {
}
export declare const ZodMiniNaN: core.$constructor<ZodMiniNaN>;
export declare function nan(params?: string | core.$ZodNaNParams): ZodMiniNaN;
export interface ZodMiniPipe<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPipeInternals<A, B>> {
}
export declare const ZodMiniPipe: core.$constructor<ZodMiniPipe>;
export declare function pipe<const A extends SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodMiniPipe<A, B>;
export interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodReadonlyInternals<T>> {
}
export declare const ZodMiniReadonly: core.$constructor<ZodMiniReadonly>;
export declare function readonly<T extends SomeType>(innerType: T): ZodMiniReadonly<T>;
export interface ZodMiniTemplateLiteral<Template extends string = string> extends _ZodMiniType<core.$ZodTemplateLiteralInternals<Template>> {
}
export declare const ZodMiniTemplateLiteral: core.$constructor<ZodMiniTemplateLiteral>;
export declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodMiniTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
export interface ZodMiniLazy<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodLazyInternals<T>> {
}
export declare const ZodMiniLazy: core.$constructor<ZodMiniLazy>;
declare function _lazy<T extends SomeType>(getter: () => T): ZodMiniLazy<T>;
export { _lazy as lazy };
export interface ZodMiniPromise<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPromiseInternals<T>> {
}
export declare const ZodMiniPromise: core.$constructor<ZodMiniPromise>;
export declare function promise<T extends SomeType>(innerType: T): ZodMiniPromise<T>;
export interface ZodMiniCustom<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodCustomInternals<O, I>> {
}
export declare const ZodMiniCustom: core.$constructor<ZodMiniCustom>;
export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
export declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodMiniCustom<O, I>;
export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
declare abstract class Class {
constructor(..._args: any[]);
}
declare function _instanceof<T extends typeof Class>(cls: T, params?: core.$ZodCustomParams): ZodMiniCustom<InstanceType<T>, InstanceType<T>>;
export { _instanceof as instanceof };
export declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniPipe<ZodMiniPipe<ZodMiniString, ZodMiniTransform<boolean, string>>, ZodMiniBoolean>;
type _ZodMiniJSONSchema = ZodMiniUnion<[
ZodMiniString,
ZodMiniNumber,
ZodMiniBoolean,
ZodMiniNull,
ZodMiniArray<ZodMiniJSONSchema>,
ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>
]>;
type _ZodMiniJSONSchemaInternals = _ZodMiniJSONSchema["_zod"];
export interface ZodMiniJSONSchemaInternals extends _ZodMiniJSONSchemaInternals {
output: util.JSONType;
input: util.JSONType;
}
export interface ZodMiniJSONSchema extends _ZodMiniJSONSchema {
_zod: ZodMiniJSONSchemaInternals;
}
export declare function json(): ZodMiniJSONSchema;

1
.pnpm-store/v10/files/51/292a350134033b69268fad884e00e3a8b952963716e090ffe3d99323ead45373c0eff3333b9a81bee82b13be79d6d1261d6140e2795d0d63b90503f9fc74d4 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../../src/fields/Upload/Input.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,mBAAmB,EAEnB,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,WAAW,IAAI,eAAe,EAC9B,iBAAiB,EAClB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAKjD,OAAO,KAA0C,MAAM,OAAO,CAAA;AAqB9D,OAAO,cAAc,CAAA;AAGrB,eAAO,MAAM,SAAS,WAAW,CAAA;AAIjC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;OAEG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,sBAAsB,CAAA;IAC5C,QAAQ,CAAC,mBAAmB,CAAC,EAAE,KAAK,CAAC,SAAS,EAAE,CAAA;IAChD,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAA;IACxC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,mBAAmB,CAAA;IAC5C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAChC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAA;IACpF,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAA,KAAK,IAAI,CAAA;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC,YAAY,CAAC,CAAA;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,iBAAiB,GAAG,iBAAiB,EAAE,CAAA;CACjG,CAAA;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,qBAysBlD"}

9
.pnpm-store/v10/files/51/2af8139bbb64b0a91e2e7c4d7ff15e463216164ab14ef9284fd45233acf7ee1500ee8ee5693203bbd648112fe063956a987ea9d1169185aae6c0ff5f0f11c7 Normal file
View File

@@ -0,0 +1,9 @@
import getServerExtractor from '../server/react-server/getServerExtractor.js';
import useConfig from './useConfig.js';
function useExtracted(namespace) {
const config = useConfig('useExtracted');
return getServerExtractor(config, namespace);
}
export { useExtracted as default };

287
.pnpm-store/v10/files/51/2b1fbc326c893156e8cab7a2d7722596da24bc227abeddc5bd81e2ccab7a6add88ee27e4e8f8353f1a94157697274a634fd35be20ea5a291bd65b063c8352a Normal file
View File

@@ -0,0 +1,287 @@
import { handleSchedulesJobsEndpoint } from '../endpoints/handleSchedules.js';
import { runJobsEndpoint } from '../endpoints/run.js';
import { getJobTaskStatus } from '../utilities/getJobTaskStatus.js';
export const jobsCollectionSlug = 'payload-jobs';
export const getDefaultJobsCollection = (jobsConfig)=>{
const workflowSlugs = new Set();
const taskSlugs = new Set([
'inline'
]);
if (jobsConfig.workflows?.length) {
jobsConfig.workflows.forEach((workflow)=>{
workflowSlugs.add(workflow.slug);
// Validate concurrency config requires enableConcurrencyControl flag
if (workflow.concurrency && !jobsConfig.enableConcurrencyControl) {
throw new Error(`Workflow "${workflow.slug}" uses concurrency controls but "jobs.enableConcurrencyControl" is not enabled. ` + `Set "jobs.enableConcurrencyControl: true" in your Payload config to use concurrency controls. ` + `Note: This adds a new indexed field to the jobs collection schema and may require a database migration.`);
}
});
}
if (jobsConfig.tasks?.length) {
jobsConfig.tasks.forEach((task)=>{
if (workflowSlugs.has(task.slug)) {
throw new Error(`Task slug "${task.slug}" is already used by a workflow. No tasks are allowed to have the same slug as a workflow.`);
}
// Validate concurrency config requires enableConcurrencyControl flag
if (task.concurrency && !jobsConfig.enableConcurrencyControl) {
throw new Error(`Task "${task.slug}" uses concurrency controls but "jobs.enableConcurrencyControl" is not enabled. ` + `Set "jobs.enableConcurrencyControl: true" in your Payload config to use concurrency controls. ` + `Note: This adds a new indexed field to the jobs collection schema and may require a database migration.`);
}
taskSlugs.add(task.slug);
});
}
const logFields = [
{
name: 'executedAt',
type: 'date',
required: true
},
{
name: 'completedAt',
type: 'date',
required: true
},
{
name: 'taskSlug',
type: 'select',
options: [
...taskSlugs
],
required: true
},
{
name: 'taskID',
type: 'text',
required: true
},
/**
* @todo make required in 4.0
*/ {
name: 'input',
type: 'json'
},
{
name: 'output',
type: 'json'
},
{
name: 'state',
type: 'radio',
options: [
'failed',
'succeeded'
],
required: true
},
{
name: 'error',
type: 'json',
admin: {
condition: (_, data)=>data.state === 'failed'
},
required: true
}
];
if (jobsConfig.addParentToTaskLog) {
logFields.push({
name: 'parent',
type: 'group',
fields: [
{
name: 'taskSlug',
type: 'select',
options: [
...taskSlugs
]
},
{
name: 'taskID',
type: 'text'
}
]
});
}
const jobsCollection = {
slug: jobsCollectionSlug,
admin: {
group: 'System',
hidden: true
},
endpoints: [
runJobsEndpoint,
handleSchedulesJobsEndpoint
],
fields: [
{
name: 'input',
type: 'json',
admin: {
description: 'Input data provided to the job'
}
},
{
name: 'taskStatus',
type: 'json',
virtual: true
},
{
type: 'tabs',
tabs: [
{
fields: [
{
name: 'completedAt',
type: 'date',
index: true
},
{
name: 'totalTried',
type: 'number',
defaultValue: 0,
index: true
},
{
name: 'hasError',
type: 'checkbox',
admin: {
description: 'If hasError is true this job will not be retried'
},
defaultValue: false,
index: true
},
{
name: 'error',
type: 'json',
admin: {
condition: (data)=>data.hasError,
description: 'If hasError is true, this is the error that caused it'
}
},
{
name: 'log',
type: 'array',
admin: {
description: 'Task execution log'
},
fields: logFields
}
],
label: 'Status'
}
]
},
// only include the workflowSlugs field if workflows exist
...workflowSlugs.size > 0 ? [
{
name: 'workflowSlug',
type: 'select',
admin: {
position: 'sidebar'
},
index: true,
options: [
...workflowSlugs
]
}
] : [],
{
name: 'taskSlug',
type: 'select',
admin: {
position: 'sidebar'
},
index: true,
options: [
...taskSlugs
],
required: false
},
{
name: 'queue',
type: 'text',
admin: {
position: 'sidebar'
},
defaultValue: 'default',
index: true
},
{
name: 'waitUntil',
type: 'date',
admin: {
date: {
pickerAppearance: 'dayAndTime'
}
},
index: true
},
{
name: 'processing',
type: 'checkbox',
admin: {
position: 'sidebar'
},
defaultValue: false,
index: true
},
// Only add concurrencyKey field if concurrency control is enabled
...jobsConfig.enableConcurrencyControl ? [
{
name: 'concurrencyKey',
type: 'text',
admin: {
description: 'Used for concurrency control. Jobs with the same key are subject to exclusive/supersedes rules.',
position: 'sidebar',
readOnly: true
},
index: true
}
] : []
],
hooks: {
afterRead: [
({ doc, req })=>{
// This hook is used to add the virtual `tasks` field to the document, that is computed from the `log` field
return jobAfterRead({
config: req.payload.config,
doc
});
}
],
/**
* If another update comes in after a job as already been cancelled, we need to make sure that update doesn't
* change the state of the job.
*/ beforeChange: [
({ data, originalDoc })=>{
if (originalDoc?.error?.cancelled) {
data.processing = false;
data.hasError = true;
delete data.completedAt;
delete data.waitUntil;
}
return data;
}
]
},
lockDocuments: false
};
if (jobsConfig.stats) {
// TODO: In 4.0, this should be added by default.
// The meta field can be used to store arbitrary data about the job. The scheduling system uses this to store
// `scheduled: true` to indicate that the job was queued by the scheduling system.
jobsCollection.fields.push({
name: 'meta',
type: 'json'
});
}
return jobsCollection;
};
// eslint-disable-next-line @typescript-eslint/no-unused-vars
export function jobAfterRead({ config, doc }) {
doc.taskStatus = getJobTaskStatus({
jobLog: doc.log || []
});
doc.input = doc.input || {};
doc.taskStatus = doc.taskStatus || {};
return doc;
}
//# sourceMappingURL=collection.js.map

161
.pnpm-store/v10/files/51/30bb3dca6f2fa9fc1b1e7579610ea52fc9cef848aa9b49fb7ba738652fad0abddeeea9c4ac124c6266c42e337f9421446393205c1fb1a3765d825fde935efb Normal file
View File

@@ -0,0 +1,161 @@
# STYLIS
[![stylis](https://stylis.js.org/assets/logo.svg)](https://github.com/thysultan/stylis.js)
A Light–weight CSS Preprocessor.
[![Coverage](https://coveralls.io/repos/github/thysultan/stylis.js/badge.svg?branch=master)](https://coveralls.io/github/thysultan/stylis.js)
[![Size](https://badgen.net/bundlephobia/minzip/stylis)](https://bundlephobia.com/result?p=stylis)
[![Licence](https://badgen.net/badge/license/MIT/blue)](https://github.com/thysultan/stylis.js/blob/master/LICENSE)
[![NPM](https://badgen.net/npm/v/dyo)](https://www.npmjs.com/package/stylis)
## Installation
* Use a Direct Download: `<script src=stylis.js></script>`
* Use a CDN: `<script src=unpkg.com/stylis></script>`
* Use NPM: `npm install stylis --save`
## Features
- nesting `a { &:hover {} }`
- selector namespacing
- vendor prefixing (flex-box, etc...)
- minification
- esm module compatible
- tree-shaking-able
## Abstract Syntax Structure
```js
const declaration = {
value: 'color:red;',
type: 'decl',
props: 'color',
children: 'red',
line: 1, column: 1
}
const comment = {
value: '/*@noflip*/',
type: 'comm',
props: '/',
children: '@noflip',
line: 1, column: 1
}
const ruleset = {
value: 'h1,h2',
type: 'rule',
props: ['h1', 'h2'],
children: [/* ... */],
line: 1, column: 1
}
const atruleset = {
value: '@media (max-width:100), (min-width:100)',
type: '@media',
props: ['(max-width:100)', '(min-width:100)'],
children: [/* ... */],
line: 1, column: 1
}
```
## Example:
```js
import {compile, serialize, stringify} from 'stylis'
serialize(compile(`h1{all:unset}`), stringify)
```
### Compile
```js
compile('h1{all:unset}') === [{value: 'h1', type: 'rule', props: ['h1'], children: [/* ... */]}]
compile('--foo:unset;') === [{value: '--foo:unset;', type: 'decl', props: '--foo', children: 'unset'}]
```
### Tokenize
```js
tokenize('h1 h2 h3 [h4 h5] fn(args) "a b c"') === ['h1', 'h2', 'h3', '[h4 h5]', 'fn', '(args)', '"a b c"']
```
### Serialize
```js
serialize(compile('h1{all:unset}'), stringify)
```
### Vendor Prefixing
```js
import {compile, serialize, stringify, middleware, prefixer } from 'stylis';
serialize(compile('div{display:flex;}'), middleware([prefixer, stringify]))
```
## Middleware
The middleware helper is a convenient helper utility, that for all intents and purposes you can do without if you intend to implement your own traversal logic. The `stringify` middleware is one such middleware that can be used in conjunction with it.
Elements passed to middlewares have a `root` property that is the immediate root/parent of the current element **in the compiled output**, so it references the parent in the already expanded CSS-like structure. Elements have also `parent` property that is the immediate parent of the current element **from the input structure** (structure representing the input string).
### Traversal
```js
serialize(compile('h1{all:unset}'), middleware([(element, index, children) => {
assert(children === element.root.children && children[index] === element.children)
}, stringify])) === 'h1{all:unset;}'
```
The abstract syntax tree also includes an additional `return` property for more niche uses.
### Prefixing
```js
serialize(compile('h1{all:unset}'), middleware([(element, index, children, callback) => {
if (element.type === 'decl' && element.props === 'all' && element.children === 'unset')
element.return = 'color:red;' + element.value
}, stringify])) === 'h1{color:red;all:unset;}'
```
```js
serialize(compile('h1{all:unset}'), middleware([(element, index, children, callback) => {
if (element.type === 'rule' && element.props.indexOf('h1') > -1)
return serialize([{...element, props: ['h2', 'h3']}], callback)
}, stringify])) === 'h2,h3{all:unset;}h1{all:unset;}'
```
### Reading
```js
serialize(compile('h1{all:unset}'), middleware([stringify, (element, index, children) => {
assert(element.return === 'h1{all:unset;}')
}])) === 'h1{all:unset;color:red;}'
```
The middlewares in [src/Middleware.js](src/Middleware.js) dive into tangible examples of how you might implement a middleware, alternatively you could also create your own middleware system as `compile` returns all the nessessary structure to fork from.
## Variables
CSS variables are supported but a note should be made about the exotic use of css variables. The css spec mentions the following
>The allowed syntax for custom properties is extremely permissive. The <declaration-value> production matches any sequence of one or more tokens, so long as the sequence does not contain <bad-string-token>, <bad-url-token>, unmatched <)-token>, <]-token>, or <}-token>, or top-level <semicolon-token> tokens or <delim-token> tokens with a value of "!".
That is to say css variables according to the spec allows: `--foo: if(x > 5) this.width = 10;` and while this value is obviously useless as a variable, and would be invalid in any normal property, it still might be read and acted on by JavaScript and this is supported by Stylis, however things become slightly undefined when we start to include the `{` and `}` productions in our use of exotic css variables.
For example consider the following: `--foo: {};`
While this is valid CSS and supported. It is unclear what should happen when the rule collides with the implicit block termination rule that allows i.e `h1{color:red}`(notice the omitted semicolon) to also be a valid CSS production. This results in the following contradiction in: `h1{--example: {}` is it to be treated as `h1{--foo:{;}` or `h1{--foo:{}` the later of which is an unterminated block or in the following: `h1{--foo:{} h1{color:red;}` should it be `h1 {--foo:{}h1{color:red;};` where `{}h1{color:red;` is part of the css variable `--foo` and not a new rule or should it be something else?
Nevertheless Stylis still supports the exotic forms highlighted in the spec, however you should consider it as a general rule to delimit such exotic uses of variables in strings or parentheses i.e: `h1{--foo:'{'}` or `h1{--foo:({)}`.
## Benchmark
Stylis is at-least 2X faster than its predecesor.
### License
Stylis is [MIT licensed](./LICENSE).

88
.pnpm-store/v10/files/51/32a5d1058606fbd5956a13dc493f34adafcee41cf31fbe5ea04870323f106d192f1d61dd5212ea0ec5eac9df16cd016c0047061622c16a36f7f28758763dcf Normal file
View File

@@ -0,0 +1,88 @@
import { parseDocumentID } from '../../index.js';
import { getFolderBreadcrumbs } from './getFolderBreadcrumbs.js';
import { queryDocumentsAndFoldersFromJoin } from './getFoldersAndDocumentsFromJoin.js';
import { getOrphanedDocs } from './getOrphanedDocs.js';
/**
* Query for documents, subfolders and breadcrumbs for a given folder
*/ export const getFolderData = async ({ collectionSlug, documentWhere, folderID: _folderID, folderWhere, req, sort = 'name' })=>{
const { payload } = req;
if (payload.config.folders === false) {
throw new Error('Folders are not enabled');
}
const parentFolderID = parseDocumentID({
id: _folderID,
collectionSlug: payload.config.folders.slug,
payload
});
const breadcrumbsPromise = getFolderBreadcrumbs({
folderID: parentFolderID,
req
});
if (parentFolderID) {
// subfolders and documents are queried together
const documentAndSubfolderPromise = queryDocumentsAndFoldersFromJoin({
documentWhere,
folderWhere,
parentFolderID,
req
});
const [breadcrumbs, result] = await Promise.all([
breadcrumbsPromise,
documentAndSubfolderPromise
]);
return {
breadcrumbs,
documents: sortDocs({
docs: result.documents,
sort
}),
folderAssignedCollections: result.folderAssignedCollections,
subfolders: sortDocs({
docs: result.subfolders,
sort
})
};
} else {
const subfoldersPromise = getOrphanedDocs({
collectionSlug: payload.config.folders.slug,
folderFieldName: payload.config.folders.fieldName,
req,
where: folderWhere
});
const [breadcrumbs, subfolders] = await Promise.all([
breadcrumbsPromise,
subfoldersPromise
]);
return {
breadcrumbs,
documents: [],
folderAssignedCollections: collectionSlug ? [
collectionSlug
] : undefined,
subfolders: sortDocs({
docs: subfolders,
sort
})
};
}
};
function sortDocs({ docs, sort }) {
if (!sort) {
return docs;
}
const isDesc = typeof sort === 'string' && sort.startsWith('-');
const sortKey = isDesc ? sort.slice(1) : sort;
return docs.sort((a, b)=>{
let result = 0;
if (sortKey === 'name') {
result = a.value._folderOrDocumentTitle.localeCompare(b.value._folderOrDocumentTitle);
} else if (sortKey === 'createdAt') {
result = new Date(a.value.createdAt || '').getTime() - new Date(b.value.createdAt || '').getTime();
} else if (sortKey === 'updatedAt') {
result = new Date(a.value.updatedAt || '').getTime() - new Date(b.value.updatedAt || '').getTime();
}
return isDesc ? -result : result;
});
}
//# sourceMappingURL=getFolderData.js.map

1
.pnpm-store/v10/files/51/32aac27512254b5f7f5ff796497c3a51c454377443b8e98e67aaa1ea884e927a24b5f93cfc8f7df22817893ae3f21cfc2fe280ba41b9ce19aaf0d19b2fc0e9 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/DraggableSortable/index.tsx"],"names":[],"mappings":"AAaA,OAAO,KAA6B,MAAM,OAAO,CAAA;AAEjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC,OAAO,EAAE,KAAK,EAAE,CAAA;AAEhB,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,KAAK,CA6E7C,CAAA"}

43
.pnpm-store/v10/files/51/32aae057c808eb025054162c3d35cb8ba020b86800d59b0f27a4f6a9d5b582ffbbfa7c1418aeb13f1b0b127c700293377b480aae3b8d96ea0de1bdc2116a54 Normal file
View File

@@ -0,0 +1,43 @@
'use strict'
const test = require('tape')
const fastURI = require('..')
const AJV = require('ajv')
const ajv = new AJV({
uriResolver: fastURI // comment this line to see it works with uri-js
})
test('ajv', t => {
t.plan(1)
const schema = {
$ref: '#/definitions/Record%3Cstring%2CPerson%3E',
definitions: {
Person: {
type: 'object',
properties: {
firstName: {
type: 'string'
}
}
},
'Record<string,Person>': {
type: 'object',
additionalProperties: {
$ref: '#/definitions/Person'
}
}
}
}
const data = {
joe: {
firstName: 'Joe'
}
}
const validate = ajv.compile(schema)
t.ok(validate(data))
})

5
.pnpm-store/v10/files/51/34108fd137186b650bf60a58472ceb6003405617f53356d344a6c8913c185a45a8b1b1d563c0dca79055cfdbe0ebcd577b9cd8f9729fb78744fba8e40953bf Normal file
View File

@@ -0,0 +1,5 @@
import { PatchedRequest } from './internal-types';
export declare const addNewStackLayer: (request: PatchedRequest) => () => void;
export declare const replaceCurrentStackRoute: (request: PatchedRequest, newRoute?: string) => void;
export declare const generateRoute: (request: PatchedRequest) => string;
//# sourceMappingURL=utils.d.ts.map

60
.pnpm-store/v10/files/51/3448a7b690e05b3a2704f21ba10d0ffd03c4266689faa57b9753cadc5cae98ec18320c5c5a9a389164f4fa291a29503eb374eec7008933745c642379ef1f24 Normal file
View File

@@ -0,0 +1,60 @@
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var sparsevec_exports = {};
__export(sparsevec_exports, {
PgSparseVector: () => PgSparseVector,
PgSparseVectorBuilder: () => PgSparseVectorBuilder,
sparsevec: () => sparsevec
});
module.exports = __toCommonJS(sparsevec_exports);
var import_entity = require("../../../entity.cjs");
var import_utils = require("../../../utils.cjs");
var import_common = require("../common.cjs");
class PgSparseVectorBuilder extends import_common.PgColumnBuilder {
static [import_entity.entityKind] = "PgSparseVectorBuilder";
constructor(name, config) {
super(name, "string", "PgSparseVector");
this.config.dimensions = config.dimensions;
}
/** @internal */
build(table) {
return new PgSparseVector(
table,
this.config
);
}
}
class PgSparseVector extends import_common.PgColumn {
static [import_entity.entityKind] = "PgSparseVector";
dimensions = this.config.dimensions;
getSQLType() {
return `sparsevec(${this.dimensions})`;
}
}
function sparsevec(a, b) {
const { name, config } = (0, import_utils.getColumnNameAndConfig)(a, b);
return new PgSparseVectorBuilder(name, config);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
PgSparseVector,
PgSparseVectorBuilder,
sparsevec
});
//# sourceMappingURL=sparsevec.cjs.map

30
.pnpm-store/v10/files/51/35c3e99c16b563b7e02208896b6be06554c928ab460f0f21eaaa5acd95b19e32fbc17b7d948f1a14b8912c172cf0f202e642b827d4e76c34f4b279c1899243 Normal file
View File

@@ -0,0 +1,30 @@
/**
* @license lucide-react v0.441.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 FolderCog = createLucideIcon("FolderCog", [
["circle", { cx: "18", cy: "18", r: "3", key: "1xkwt0" }],
[
"path",
{
d: "M10.3 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 2v3.3",
key: "1k8050"
}
],
["path", { d: "m21.7 19.4-.9-.3", key: "1qgwi9" }],
["path", { d: "m15.2 16.9-.9-.3", key: "1t7mvx" }],
["path", { d: "m16.6 21.7.3-.9", key: "1j67ps" }],
["path", { d: "m19.1 15.2.3-.9", key: "18r7jp" }],
["path", { d: "m19.6 21.7-.4-1", key: "z2vh2" }],
["path", { d: "m16.8 15.3-.4-1", key: "1ei7r6" }],
["path", { d: "m14.3 19.6 1-.4", key: "11sv9r" }],
["path", { d: "m20.7 16.8 1-.4", key: "19m87a" }]
]);
export { FolderCog as default };
//# sourceMappingURL=folder-cog.js.map

1
.pnpm-store/v10/files/51/3943ceaf23f0ef43c3674482c6b6c61e362d83eb5928905c8b969c6a755a642a402975d4c004fb8c6b7a424364d5c470e98d2f79da0125a0540a10854e017f Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/types-hoist/link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAElE,KAAK,kBAAkB,GAAG;IACxB;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAChD,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAC,CAAC;AAEnD,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,OAAO,EAAE,eAAe,CAAC;IACzB;;OAEG;IACH,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC"}

120
.pnpm-store/v10/files/51/3c393c946b0bd416bece923e8472065ef35ca096076317d23f689e0dd8313f82ed2e87f92a210155ff0b7dec22a6ca3f9628fd397c89d0555aa6d7ec0ced21 Normal file
View File

@@ -0,0 +1,120 @@
[
[
{
"host": "10.10.10.10.example.com"
},
"//10.10.10.10.example.com"
],
[
{
"host": "2001:db8::7"
},
"//[2001:db8::7]"
],
[
{
"host": "::ffff:129.144.52.38"
},
"//[::ffff:129.144.52.38]"
],
[
{
"host": "2606:2800:220:1:248:1893:25c8:1946"
},
"//[2606:2800:220:1:248:1893:25c8:1946]"
],
[
{
"host": "10.10.10.10.example.com"
},
"//10.10.10.10.example.com"
],
[
{
"host": "10.10.10.10"
},
"//10.10.10.10"
],
[
{
"path": "?query"
},
"%3Fquery"
],
[
{
"path": "foo:bar"
},
"foo%3Abar"
],
[
{
"path": "//path"
},
"/%2Fpath"
],
[
{
"scheme": "uri",
"host": "example.com",
"port": "9000"
},
"uri://example.com:9000"
],
[
{
"scheme": "uri",
"userinfo": "foo:bar",
"host": "example.com",
"port": 1,
"path": "path",
"query": "query",
"fragment": "fragment"
},
"uri://foo:bar@example.com:1/path?query#fragment"
],
[
{
"scheme": "",
"userinfo": "",
"host": "",
"port": 0,
"path": "",
"query": "",
"fragment": ""
},
"//@:0?#"
],
[
{},
""
],
[
{
"host": "fe80::a%en1"
},
"//[fe80::a%25en1]"
],
[
{
"host": "fe80::a%25en1"
},
"//[fe80::a%25en1]"
],
[
{
"scheme": "wss",
"host": "example.com",
"path": "/foo",
"query": "bar"
},
"wss://example.com/foo?bar"
],
[
{
"scheme": "scheme",
"path": "with:colon"
},
"scheme:with:colon"
]
]

602
.pnpm-store/v10/files/51/3ca2ea86b72e51be2fd6de32075b923d589c3f17ce9097f0e0d52e6f16dbc75156f3f6b77b70ddd2ae99fe490c232f749ff47934f803526956aa8fff485b60 Normal file
View File

@@ -0,0 +1,602 @@
export const slTranslations = {
authentication: {
account: 'Račun',
accountOfCurrentUser: 'Račun trenutnega uporabnika',
accountVerified: 'Račun uspešno preverjen.',
alreadyActivated: 'Že aktivirano',
alreadyLoggedIn: 'Že prijavljeni',
apiKey: 'API ključ',
authenticated: 'Avtenticirano',
backToLogin: 'Nazaj na prijavo',
beginCreateFirstUser: 'Za začetek ustvarite prvega uporabnika.',
changePassword: 'Spremeni geslo',
checkYourEmailForPasswordReset: 'Če je e-poštni naslov povezan z računom, boste kmalu prejeli navodila za ponastavitev gesla. Prosimo, preverite mapo za neželeno pošto ali spam, če e-pošte ne vidite v vašem prejemu.',
confirmGeneration: 'Potrdi generiranje',
confirmPassword: 'Potrdi geslo',
createFirstUser: 'Ustvari prvega uporabnika',
emailNotValid: 'Vneseni e-poštni naslov ni veljaven',
emailOrUsername: 'E-pošta ali uporabniško ime',
emailSent: 'E-pošta poslana',
emailVerified: 'E-pošta uspešno preverjena.',
enableAPIKey: 'Omogoči API ključ',
failedToUnlock: 'Odklepanje ni uspelo',
forceUnlock: 'Prisili odklepanje',
forgotPassword: 'Pozabljeno geslo',
forgotPasswordEmailInstructions: 'Vnesite svoj e-poštni naslov. Prejeli boste e-pošto z navodili za ponastavitev gesla.',
forgotPasswordQuestion: 'Ste pozabili geslo?',
forgotPasswordUsernameInstructions: 'Vnesite svoje uporabniško ime. Navodila za ponastavitev gesla bodo poslana na e-poštni naslov, povezan z vašim uporabniškim imenom.',
generate: 'Generiraj',
generateNewAPIKey: 'Generiraj nov API ključ',
generatingNewAPIKeyWillInvalidate: 'Generiranje novega API ključa bo <1>razveljavilo</1> prejšnji ključ. Ste prepričani, da želite nadaljevati?',
lockUntil: 'Zakleni do',
logBackIn: 'Ponovno se prijavi',
loggedIn: 'Za prijavo z drugim uporabnikom se morate najprej <0>odjaviti</0>.',
loggedInChangePassword: 'Za spremembo gesla pojdite na svoj <0>račun</0> in tam uredite svoje geslo.',
loggedOutInactivity: 'Odjavljeni ste bili zaradi neaktivnosti.',
loggedOutSuccessfully: 'Uspešno ste se odjavili.',
loggingOut: 'Odjavljanje...',
login: 'Prijava',
loginAttempts: 'Poskusi prijave',
loginUser: 'Prijavi uporabnika',
loginWithAnotherUser: 'Za prijavo z drugim uporabnikom se morate najprej <0>odjaviti</0>.',
logOut: 'Odjava',
logout: 'Odjava',
logoutSuccessful: 'Odjava uspešna.',
logoutUser: 'Odjavi uporabnika',
newAccountCreated: 'Pravkar je bil ustvarjen nov račun za dostop do <a href="{{serverURL}}">{{serverURL}}</a> Prosimo, kliknite na naslednjo povezavo ali jo prilepite v svoj brskalnik za potrditev e-pošte: <a href="{{verificationURL}}">{{verificationURL}}</a><br> Po potrditvi e-pošte se boste lahko uspešno prijavili.',
newAPIKeyGenerated: 'Nov API ključ generiran.',
newPassword: 'Novo geslo',
passed: 'Avtentikacija uspešna',
passwordResetSuccessfully: 'Geslo uspešno ponastavljeno.',
resetPassword: 'Ponastavi geslo',
resetPasswordExpiration: 'Potek ponastavitve gesla',
resetPasswordToken: 'Žeton za ponastavitev gesla',
resetYourPassword: 'Ponastavite svoje geslo',
stayLoggedIn: 'Ostani prijavljen',
successfullyRegisteredFirstUser: 'Uspešno registriran prvi uporabnik.',
successfullyUnlocked: 'Uspešno odklenjeno',
tokenRefreshSuccessful: 'Osvežitev žetona uspešna.',
unableToVerify: 'Ni mogoče preveriti',
username: 'Uporabniško ime',
usernameNotValid: 'Vneseno uporabniško ime ni veljavno',
verified: 'Preverjeno',
verifiedSuccessfully: 'Uspešno preverjeno',
verify: 'Preveri',
verifyUser: 'Preveri uporabnika',
verifyYourEmail: 'Potrdite svojo e-pošto',
youAreInactive: 'Že nekaj časa niste bili aktivni in boste kmalu samodejno odjavljeni zaradi varnosti. Želite ostati prijavljeni?',
youAreReceivingResetPassword: 'To sporočilo ste prejeli, ker ste vi (ali nekdo drug) zahtevali ponastavitev gesla za vaš račun. Prosimo, kliknite na naslednjo povezavo ali jo prilepite v svoj brskalnik za dokončanje postopka:',
youDidNotRequestPassword: 'Če tega niste zahtevali, prezrite to e-pošto in vaše geslo bo ostalo nespremenjeno.'
},
dashboard: {
addWidget: 'Dodaj pripomoček',
deleteWidget: 'Izbriši pripomoček {{id}}',
searchWidgets: 'Išči gradnike...'
},
error: {
accountAlreadyActivated: 'Ta račun je že aktiviran.',
autosaving: 'Pri samodejnem shranjevanju tega dokumenta je prišlo do težave.',
correctInvalidFields: 'Prosimo, popravite neveljavna polja.',
deletingFile: 'Pri brisanju datoteke je prišlo do napake.',
deletingTitle: 'Pri brisanju {{title}} je prišlo do napake. Prosimo, preverite povezavo in poskusite znova.',
documentNotFound: 'Dokumenta z ID {{id}} ni bilo mogoče najti. Morda je bil izbrisan ali nikoli ni obstajal, ali pa do njega nimate dostopa.',
emailOrPasswordIncorrect: 'Vnesena e-pošta ali geslo je napačno.',
followingFieldsInvalid_one: 'Naslednje polje je neveljavno:',
followingFieldsInvalid_other: 'Naslednja polja so neveljavna:',
incorrectCollection: 'Napačna zbirka',
insufficientClipboardPermissions: 'Dostop do odložišča je bil zavrnjen. Preverite dovoljenja za odložišče.',
invalidClipboardData: 'Neveljavni podatki v odložišču.',
invalidFileType: 'Neveljaven tip datoteke',
invalidFileTypeValue: 'Neveljaven tip datoteke: {{value}}',
invalidRequestArgs: 'V zahtevi so bili poslani neveljavni argumenti: {{args}}',
loadingDocument: 'Pri nalaganju dokumenta z ID-jem {{id}} je prišlo do težave.',
localesNotSaved_one: 'Naslednjega jezika ni bilo mogoče shraniti:',
localesNotSaved_other: 'Naslednjih jezikov ni bilo mogoče shraniti:',
logoutFailed: 'Odjava ni uspela.',
missingEmail: 'Manjka e-pošta.',
missingIDOfDocument: 'Manjka ID dokumenta za posodobitev.',
missingIDOfVersion: 'Manjka ID različice.',
missingRequiredData: 'Manjkajo zahtevani podatki.',
noFilesUploaded: 'Nobena datoteka ni bila naložena.',
noMatchedField: 'Za "{{label}}" ni bilo najdeno ujemajoče se polje',
notAllowedToAccessPage: 'Nimate dovoljenja za dostop do te strani.',
notAllowedToPerformAction: 'Nimate dovoljenja za izvedbo tega dejanja.',
notFound: 'Zahtevani vir ni bil najden.',
noUser: 'Ni uporabnika',
previewing: 'Pri predogledu tega dokumenta je prišlo do težave.',
problemUploadingFile: 'Pri nalaganju datoteke je prišlo do težave.',
restoringTitle: 'Pri obnavljanju {{title}} je prišlo do napake. Prosimo, preverite svojo povezavo in poskusite znova.',
revertingDocument: 'Pri vračanju tega dokumenta je prišlo do težave.',
tokenInvalidOrExpired: 'Žeton je neveljaven ali je potekel.',
tokenNotProvided: 'Žeton ni bil posredovan.',
unableToCopy: 'Kopiranje ni mogoče.',
unableToDeleteCount: 'Ni bilo mogoče izbrisati {{count}} od {{total}} {{label}}.',
unableToReindexCollection: 'Napaka pri reindeksiranju zbirke {{collection}}. Operacija je bila prekinjena.',
unableToUpdateCount: 'Ni bilo mogoče posodobiti {{count}} od {{total}} {{label}}.',
unauthorized: 'Neavtorizirano, za to zahtevo morate biti prijavljeni.',
unauthorizedAdmin: 'Neavtorizirano, ta uporabnik nima dostopa do skrbniškega vmesnika.',
unknown: 'Prišlo je do neznane napake.',
unPublishingDocument: 'Pri umiku objave tega dokumenta je prišlo do težave.',
unspecific: 'Prišlo je do napake.',
unverifiedEmail: 'Pred prijavo preverite svoj e-poštni naslov.',
userEmailAlreadyRegistered: 'Uporabnik s tem e-poštnim naslovom je že registriran.',
userLocked: 'Ta uporabnik je zaklenjen zaradi prevelikega števila neuspešnih poskusov prijave.',
usernameAlreadyRegistered: 'Uporabnik s tem uporabniškim imenom je že registriran.',
usernameOrPasswordIncorrect: 'Vneseno uporabniško ime ali geslo je napačno.',
valueMustBeUnique: 'Vrednost mora biti unikatna',
verificationTokenInvalid: 'Žeton za preverjanje je neveljaven.'
},
fields: {
addLabel: 'Dodaj {{label}}',
addLink: 'Dodaj povezavo',
addNew: 'Dodaj novo',
addNewLabel: 'Dodaj nov {{label}}',
addRelationship: 'Dodaj povezavo',
addUpload: 'Dodaj nalaganje',
block: 'Blok',
blocks: 'bloki',
blockType: 'Tip bloka',
chooseBetweenCustomTextOrDocument: 'Izberite med vnosom URL-ja po meri ali povezavo na drug dokument.',
chooseDocumentToLink: 'Izberite dokument za povezavo',
chooseFromExisting: 'Izberite iz obstoječih',
chooseLabel: 'Izberite {{label}}',
collapseAll: 'Strni vse',
customURL: 'URL po meri',
editLabelData: 'Uredi podatke {{label}}',
editLink: 'Uredi povezavo',
editRelationship: 'Uredi povezavo',
enterURL: 'Vnesite URL',
internalLink: 'Notranja povezava',
itemsAndMore: '{{items}} in še {{count}}',
labelRelationship: '{{label}} povezava',
latitude: 'Zemljepisna širina',
linkedTo: 'Povezano z <0>{{label}}</0>',
linkType: 'Tip povezave',
longitude: 'Zemljepisna dolžina',
newLabel: 'Nov {{label}}',
openInNewTab: 'Odpri v novem zavihku',
passwordsDoNotMatch: 'Gesli se ne ujemata.',
relatedDocument: 'Povezan dokument',
relationTo: 'Povezava z',
removeRelationship: 'Odstrani povezavo',
removeUpload: 'Odstrani nalaganje',
saveChanges: 'Shrani spremembe',
searchForBlock: 'Išči blok',
searchForLanguage: 'Išči jezik',
selectExistingLabel: 'Izberi obstoječ {{label}}',
selectFieldsToEdit: 'Izberi polja za urejanje',
showAll: 'Pokaži vse',
swapRelationship: 'Zamenjaj povezavo',
swapUpload: 'Zamenjaj nalaganje',
textToDisplay: 'Besedilo za prikaz',
toggleBlock: 'Preklopi blok',
uploadNewLabel: 'Naloži nov {{label}}'
},
folder: {
browseByFolder: 'Brskaj po mapi',
byFolder: 'Po mapi',
deleteFolder: 'Izbriši mapo',
folderName: 'Ime mape',
folders: 'Mape',
folderTypeDescription: 'Izberite, katere vrste dokumentov zbirke naj bodo dovoljene v tej mapi.',
itemHasBeenMoved: '{{title}} je bil premaknjen v {{folderName}}',
itemHasBeenMovedToRoot: '{{title}} je bil premaknjen v korensko mapo.',
itemsMovedToFolder: '{{title}} premaknjeno v {{folderName}}',
itemsMovedToRoot: '{{title}} premaknjeno v korensko mapo',
moveFolder: 'Premakni mapo',
moveItemsToFolderConfirmation: 'Ravno se pripravljate na premik <1>{{count}} {{label}}</1> v mapo <2>{{toFolder}}</2>. Ste prepričani?',
moveItemsToRootConfirmation: 'Ravno boste premaknili <1>{{count}} {{label}}</1> v korensko mapo. Ste prepričani?',
moveItemToFolderConfirmation: 'Pravkar boste premaknili <1>{{title}}</1> v <2>{{toFolder}}</2>. Ste prepričani?',
moveItemToRootConfirmation: 'Pravkar boste premaknili <1>{{title}}</1> v korensko mapo. Ali ste prepričani?',
movingFromFolder: 'Premik {{title}} iz {{fromFolder}}',
newFolder: 'Nova mapa',
noFolder: 'Brez mape',
renameFolder: 'Preimenuj Mapo',
searchByNameInFolder: 'Iskanje po imenu v {{folderName}}',
selectFolderForItem: 'Izberite mapo za {{title}}'
},
general: {
name: 'Ime',
aboutToDelete: 'Izbrisali boste {{label}} <1>{{title}}</1>. Ste prepričani?',
aboutToDeleteCount_many: 'Izbrisali boste {{count}} {{label}}',
aboutToDeleteCount_one: 'Izbrisali boste {{count}} {{label}}',
aboutToDeleteCount_other: 'Izbrisali boste {{count}} {{label}}',
aboutToPermanentlyDelete: 'Ravno boste trajno izbrisali {{label}} <1>{{title}}</1>. Ste prepričani?',
aboutToPermanentlyDeleteTrash: 'Pravkar boste trajno izbrisali <0>{{count}}</0> <1>{{label}}</1> iz smetnjaka. Ali ste prepričani?',
aboutToRestore: 'Ravno se odpravljate na obnovitev {{label}} <1>{{title}}</1>. Ste prepričani?',
aboutToRestoreAsDraft: 'Pravkar boste obnovili {{label}} <1>{{title}}</1> kot osnutek. Ali ste prepričani?',
aboutToRestoreAsDraftCount: 'Pravkar boste obnovili {{count}} {{label}} kot osnutek.',
aboutToRestoreCount: 'Pravkar boste obnovili {{count}} {{label}}',
aboutToTrash: 'Pravkar boste premaknili {{label}} <1>{{title}}</1> v smeti. Ste prepričani?',
aboutToTrashCount: 'Pravkar boste premaknili {{count}} {{label}} v smeti.',
addBelow: 'Dodaj spodaj',
addFilter: 'Dodaj filter',
adminTheme: 'Tema skrbnika',
all: 'Vse',
allCollections: 'Vse Zbirke',
allLocales: 'Vse lokacije',
and: 'In',
anotherUser: 'Drug uporabnik',
anotherUserTakenOver: 'Drug uporabnik je prevzel urejanje tega dokumenta.',
applyChanges: 'Uporabi spremembe',
ascending: 'Naraščajoče',
automatic: 'Samodejno',
backToDashboard: 'Nazaj na nadzorno ploščo',
cancel: 'Prekliči',
changesNotSaved: 'Vaše spremembe niso shranjene. Če zapustite zdaj, boste izgubili svoje spremembe.',
clear: 'Čisto',
clearAll: 'Počisti vse',
close: 'Zapri',
collapse: 'Strni',
collections: 'Zbirke',
columns: 'Stolpci',
columnToSort: 'Stolpec za razvrščanje',
confirm: 'Potrdi',
confirmCopy: 'Potrdi kopiranje',
confirmDeletion: 'Potrdi brisanje',
confirmDuplication: 'Potrdi podvajanje',
confirmMove: 'Potrdi premik',
confirmReindex: 'Ponovno indeksirati vse {{collections}}?',
confirmReindexAll: 'Ponovno indeksirati vse zbirke?',
confirmReindexDescription: 'To bo odstranilo obstoječe indekse in ponovno indeksiralo dokumente v zbirkah {{collections}}.',
confirmReindexDescriptionAll: 'To bo odstranilo obstoječe indekse in ponovno indeksiralo dokumente v vseh zbirkah.',
confirmRestoration: 'Potrdite obnovitev',
copied: 'Kopirano',
copy: 'Kopiraj',
copyField: 'Kopiraj polje',
copying: 'Kopiranje',
copyRow: 'Kopiraj vrstico',
copyWarning: 'Prepisali boste {{to}} z {{from}} za {{label}} {{title}}. Ste prepričani?',
create: 'Ustvari',
created: 'Ustvarjeno',
createdAt: 'Ustvarjeno',
createNew: 'Ustvari novo',
createNewLabel: 'Ustvari nov {{label}}',
creating: 'Ustvarjanje',
creatingNewLabel: 'Ustvarjanje novega {{label}}',
currentlyEditing: 'trenutno ureja ta dokument. Če prevzamete, jim bo onemogočeno nadaljnje urejanje in lahko izgubijo neshranjene spremembe.',
custom: 'Po meri',
dark: 'Temno',
dashboard: 'Nadzorna plošča',
delete: 'Izbriši',
deleted: 'Izbrisano',
deletedAt: 'Izbrisano ob',
deletedCountSuccessfully: 'Uspešno izbrisano {{count}} {{label}}.',
deletedSuccessfully: 'Uspešno izbrisano.',
deleteLabel: 'Izbriši {{label}}',
deletePermanently: 'Preskoči smetnjak in trajno izbriši',
deleting: 'Brisanje...',
depth: 'Globina',
descending: 'Padajoče',
deselectAllRows: 'Odznači vse vrstice',
document: 'Dokument',
documentIsTrashed: 'Ta {{label}} je v smetnjaku in je samo za branje.',
documentLocked: 'Dokument zaklenjen',
documents: 'Dokumenti',
duplicate: 'Podvoji',
duplicateWithoutSaving: 'Podvoji brez shranjevanja sprememb',
edit: 'Uredi',
editAll: 'Uredi vse',
editedSince: 'Urejeno od',
editing: 'Urejanje',
editingLabel_many: 'Urejanje {{count}} {{label}}',
editingLabel_one: 'Urejanje {{count}} {{label}}',
editingLabel_other: 'Urejanje {{count}} {{label}}',
editingTakenOver: 'Urejanje prevzeto',
editLabel: 'Uredi {{label}}',
email: 'E-pošta',
emailAddress: 'E-poštni naslov',
emptyTrash: 'Izprazni koš',
emptyTrashLabel: 'Izprazni {{label}} smeti',
enterAValue: 'Vnesite vrednost',
error: 'Napaka',
errors: 'Napake',
exitLivePreview: 'Izhodi iz živega predogleda',
export: 'Izvoz',
fallbackToDefaultLocale: 'Uporabi privzeti jezik',
false: 'Ne',
filter: 'Filter',
filters: 'Filtri',
filterWhere: 'Filtriraj {{label}} kjer',
globals: 'Globalne nastavitve',
goBack: 'Nazaj',
groupByLabel: 'Razvrsti po {{label}}',
import: 'Uvoz',
isEditing: 'ureja',
item: 'Predmet',
items: 'predmeti',
language: 'Jezik',
lastModified: 'Zadnja sprememba',
layout: 'Postavitev',
leaveAnyway: 'Vseeno zapusti',
leaveWithoutSaving: 'Zapusti brez shranjevanja',
light: 'Svetlo',
livePreview: 'Predogled',
loading: 'Nalaganje',
locale: 'Jezik',
locales: 'Jeziki',
lock: 'Zakleni',
menu: 'Meni',
moreOptions: 'Več možnosti',
move: 'Premakni',
moveConfirm: 'Pravkar boste premaknili {{count}} {{label}} na <1>{{destination}}</1>. Ste prepričani?',
moveCount: 'Premakni {{count}} {{label}}',
moveDown: 'Premakni dol',
moveUp: 'Premakni gor',
moving: 'Premikanje',
movingCount: 'Premikanje {{count}} {{label}}',
newLabel: 'Nov {{label}}',
newPassword: 'Novo geslo',
next: 'Naprej',
no: 'Ne',
noDateSelected: 'Izbran ni noben datum',
noFiltersSet: 'Ni nastavljenih filtrov',
noLabel: '<Brez {{label}}>',
none: 'Brez',
noOptions: 'Ni možnosti',
noResults: 'Ni najdenih {{label}}. Ali {{label}} še ne obstajajo ali pa ne ustrezajo filtrom, ki ste jih določili zgoraj.',
noResultsDescription: 'Bodisi ne obstajajo ali pa nobeden ne ustreza filtri, ki ste jih določili zgoraj.',
noResultsFound: 'Ni rezultatov.',
notFound: 'Ni najdeno',
nothingFound: 'Nič ni najdeno',
noTrashResults: 'Ni {{label}} v smetnjaku.',
noUpcomingEventsScheduled: 'Ni načrtovanih prihajajočih dogodkov.',
noValue: 'Ni vrednosti',
of: 'od',
only: 'Samo',
open: 'Odpri',
or: 'Ali',
order: 'Vrstni red',
overwriteExistingData: 'Prepišite obstoječe podatke polja',
pageNotFound: 'Stran ni najdena',
password: 'Geslo',
pasteField: 'Prilepi polje',
pasteRow: 'Prilepi vrstico',
payloadSettings: 'Nastavitve Payloada',
permanentlyDelete: 'Trajno Izbrisano',
permanentlyDeletedCountSuccessfully: 'Uspešno trajno izbrisano {{count}} {{label}}.',
perPage: 'Na stran: {{limit}}',
previous: 'Prejšnji',
reindex: 'Reindeksiraj',
reindexingAll: 'Ponovno indeksiranje vseh {{collections}}.',
remove: 'Odstrani',
rename: 'Preimenuj',
reset: 'Ponastavi',
resetPreferences: 'Ponastavi nastavitve',
resetPreferencesDescription: 'To bo ponastavilo vse vaše nastavitve na privzete vrednosti.',
resettingPreferences: 'Ponastavitev nastavitve.',
restore: 'Obnovi',
restoreAsPublished: 'Obnovi kot objavljeno različico',
restoredCountSuccessfully: 'Uspešno obnovljeno {{count}} {{label}}.',
restoring: 'Spoštujte pomen izvirnega besedila znotraj konteksta Payload. Tu je seznam pogostih izrazov Payload, ki imajo zelo specifične pomene:\n - Zbirka: Zbirka je skupina dokumentov, ki delijo skupno strukturo in namen. Zbirke se uporabljajo za organizacijo in upravljanje vsebine v Payload.\n - Polje: Polje je določen del podatkov znotraj dokumenta v zbirki. Polja opredeljujejo strukturo in vrsto podatkov, ki jih je mogoče sh',
row: 'Vrstica',
rows: 'Vrstice',
save: 'Shrani',
saveChanges: 'Shrani Spremembe',
saving: 'Shranjevanje...',
schedulePublishFor: 'Načrtujte objavo za {{naslov}}',
searchBy: 'Išči po {{label}}',
select: 'Izberi',
selectAll: 'Izberi vse {{count}} {{label}}',
selectAllRows: 'Izberi vse vrstice',
selectedCount: '{{count}} {{label}} izbranih',
selectLabel: 'Izberite {{label}}',
selectValue: 'Izberi vrednost',
showAllLabel: 'Pokaži vse {{label}}',
sorryNotFound: 'Oprostite - ničesar ni mogoče najti, kar bi ustrezalo vaši zahtevi.',
sort: 'Razvrsti',
sortByLabelDirection: 'Razvrsti po {{label}} {{direction}}',
stayOnThisPage: 'Ostani na tej strani',
submissionSuccessful: 'Oddaja uspešna.',
submit: 'Oddaj',
submitting: 'Oddajanje...',
success: 'Uspeh',
successfullyCreated: '{{label}} uspešno ustvarjen.',
successfullyDuplicated: '{{label}} uspešno podvojen.',
successfullyReindexed: 'Uspešno je bilo ponovo indeksiranih {{count}} od skupno {{total}} dokumentov iz {{collections}}, in {{skips}} osnutkov je bilo preskočenih.',
takeOver: 'Prevzemi',
thisLanguage: 'Slovenščina',
time: 'Čas',
timezone: 'Časovni pas',
titleDeleted: '{{label}} "{{title}}" uspešno izbrisan.',
titleRestored: 'Oznaka "{{title}}" je bila uspešno obnovljena.',
titleTrashed: '{{label}} "{{title}}" premaknjeno v smeti.',
trash: 'Smeti',
trashedCountSuccessfully: '{{count}} {{label}} premaknjeno v smeti.',
true: 'Da',
unauthorized: 'Nepooblaščeno',
unlock: 'Odkleni',
unsavedChanges: 'Neshranjene spremembe',
unsavedChangesDuplicate: 'Imate neshranjene spremembe. Želite nadaljevati s podvajanjem?',
untitled: 'Brez naslova',
upcomingEvents: 'Prihajajoči dogodki',
updatedAt: 'Posodobljeno',
updatedCountSuccessfully: 'Uspešno posodobljeno {{count}} {{label}}.',
updatedLabelSuccessfully: '{{label}} uspešno posodobljen.',
updatedSuccessfully: 'Uspešno posodobljeno.',
updateForEveryone: 'Posodobitev za vse',
updating: 'Posodabljanje',
uploading: 'Nalaganje',
uploadingBulk: 'Nalaganje {{current}} od {{total}}',
user: 'Uporabnik',
username: 'Uporabniško ime',
users: 'Uporabniki',
value: 'Vrednost',
viewing: 'Ogled',
viewReadOnly: 'Ogled samo za branje',
welcome: 'Dobrodošli',
yes: 'Da'
},
localization: {
cannotCopySameLocale: 'Ni mogoče kopirati v isti jezik',
copyFrom: 'Kopiraj iz',
copyFromTo: 'Kopiranje iz {{from}} v {{to}}',
copyTo: 'Kopiraj v',
copyToLocale: 'Kopiraj v jezik',
localeToPublish: 'Lokalno za objavo',
selectedLocales: 'Izbrane regionalne nastavitve',
selectLocaleToCopy: 'Izberite jezik za kopiranje',
selectLocaleToDuplicate: 'Izberite jezikovne nastavitve za podvojitev'
},
operators: {
contains: 'vsebuje',
equals: 'je enako',
exists: 'obstaja',
intersects: 'se seka',
isGreaterThan: 'je večje od',
isGreaterThanOrEqualTo: 'je večje ali enako',
isIn: 'je v',
isLessThan: 'je manjše od',
isLessThanOrEqualTo: 'je manjše ali enako',
isLike: 'je podobno',
isNotEqualTo: 'ni enako',
isNotIn: 'ni v',
isNotLike: 'ni podobno',
near: 'blizu',
within: 'znotraj'
},
upload: {
addFile: 'Dodaj datoteko',
addFiles: 'Dodaj datoteke',
bulkUpload: 'Množično nalaganje',
crop: 'Obreži',
cropToolDescription: 'Povlecite kote izbranega območja, narišite novo območje ali prilagodite vrednosti spodaj.',
download: 'Prenos',
dragAndDrop: 'Povlecite in spustite datoteko',
dragAndDropHere: 'ali povlecite in spustite datoteko sem',
editImage: 'Uredi sliko',
fileName: 'Ime datoteke',
fileSize: 'Velikost datoteke',
filesToUpload: 'Datoteke za nalaganje',
fileToUpload: 'Datoteka za nalaganje',
focalPoint: 'Žarišče',
focalPointDescription: 'Povlecite žarišče neposredno na predogledu ali prilagodite vrednosti spodaj.',
height: 'Višina',
lessInfo: 'Manj informacij',
moreInfo: 'Več informacij',
noFile: 'Ni datoteke.',
pasteURL: 'Prilepi URL',
previewSizes: 'Velikosti predogleda',
selectCollectionToBrowse: 'Izberite zbirko za brskanje',
selectFile: 'Izberite datoteko',
setCropArea: 'Nastavi območje obrezovanja',
setFocalPoint: 'Nastavi žarišče',
sizes: 'Velikosti',
sizesFor: 'Velikosti za {{label}}',
width: 'Širina'
},
validation: {
emailAddress: 'Vnesite veljaven e-poštni naslov.',
enterNumber: 'Vnesite veljavno številko.',
fieldHasNo: 'To polje nima {{label}}',
greaterThanMax: '{{value}} je večje od največje dovoljene {{label}} {{max}}.',
invalidBlock: 'Blok "{{block}}" ni dovoljen.',
invalidBlocks: 'To polje vsebuje bloke, ki niso več dovoljeni: {{blocks}}.',
invalidInput: 'To polje ima neveljaven vnos.',
invalidSelection: 'To polje ima neveljavno izbiro.',
invalidSelections: 'To polje ima naslednje neveljavne izbire:',
latitudeOutOfBounds: 'Zemljepisna širina mora biti med -90 in 90.',
lessThanMin: '{{value}} je manjše od najmanjše dovoljene {{label}} {{min}}.',
limitReached: 'Dosežena omejitev, dodati je mogoče samo {{max}} elementov.',
longerThanMin: 'Ta vrednost mora biti daljša od najmanjše dolžine {{minLength}} znakov.',
longitudeOutOfBounds: 'Zemljepisna dolžina mora biti med -180 in 180.',
notValidDate: '"{{value}}" ni veljaven datum.',
required: 'To polje je obvezno.',
requiresAtLeast: 'To polje zahteva vsaj {{count}} {{label}}.',
requiresNoMoreThan: 'To polje zahteva največ {{count}} {{label}}.',
requiresTwoNumbers: 'To polje zahteva dve številki.',
shorterThanMax: 'Ta vrednost mora biti krajša od največje dolžine {{maxLength}} znakov.',
timezoneRequired: 'Potrebna je časovna cona.',
trueOrFalse: 'To polje je lahko samo enako true ali false.',
username: 'Vnesite veljavno uporabniško ime. Lahko vsebuje črke, številke, vezaje, pike in podčrtaje.',
validUploadID: 'To polje ni veljaven ID nalaganja.'
},
version: {
type: 'Tip',
aboutToPublishSelection: 'Objavili boste vse {{label}} v izboru. Ste prepričani?',
aboutToRestore: 'Ta {{label}} dokument boste obnovili v stanje, v katerem je bil {{versionDate}}.',
aboutToRestoreGlobal: 'Globalni {{label}} boste obnovili v stanje, v katerem je bil {{versionDate}}.',
aboutToRevertToPublished: 'Spremembe tega dokumenta boste povrnili v objavljeno stanje. Ste prepričani?',
aboutToUnpublish: 'Ta dokument boste umaknili iz objave. Ste prepričani?',
aboutToUnpublishIn: 'Ravno boste prenehali objavljati ta dokument v {{locale}}. Ali ste prepričani?',
aboutToUnpublishSelection: 'Umaknili boste iz objave vse {{label}} v izboru. Ste prepričani?',
autosave: 'Samodejno shranjevanje',
autosavedSuccessfully: 'Samodejno shranjeno uspešno.',
autosavedVersion: 'Samodejno shranjena različica',
changed: 'Spremenjeno',
changedFieldsCount_one: '{{count}} spremenjeno polje',
changedFieldsCount_other: '{{count}} spremenjena polja',
compareVersion: 'Primerjaj različico z:',
compareVersions: 'Primerjaj različice',
comparingAgainst: 'Primerjava z',
confirmPublish: 'Potrdi objavo',
confirmRevertToSaved: 'Potrdi vrnitev na shranjeno',
confirmUnpublish: 'Potrdi umik objave',
confirmVersionRestoration: 'Potrdi obnovitev različice',
currentDocumentStatus: 'Trenutni {{docStatus}} dokument',
currentDraft: 'Trenutni osnutek',
currentlyPublished: 'Trenutno objavljeno',
currentlyViewing: 'Trenutno pregledujete',
currentPublishedVersion: 'Trenutna objavljena različica',
draft: 'Osnutek',
draftHasPublishedVersion: 'Osnutek (ima objavljeno različico)',
draftSavedSuccessfully: 'Osnutek uspešno shranjen.',
lastSavedAgo: 'Nazadnje shranjeno pred {{distance}}',
modifiedOnly: 'Samo spremenjeno',
moreVersions: 'Več različic...',
noFurtherVersionsFound: 'Ni najdenih nadaljnjih različic',
noLabelGroup: 'Neimenovana skupina',
noRowsFound: 'Ni najdenih {{label}}',
noRowsSelected: 'Ni izbranih {{label}}',
preview: 'Predogled',
previouslyDraft: 'Prej osnutek',
previouslyPublished: 'Predhodno objavljeno',
previousVersion: 'Prejšnja različica',
problemRestoringVersion: 'Pri obnavljanju te različice je prišlo do težave',
publish: 'Objavi',
publishAllLocales: 'Objavi vse jezike',
publishChanges: 'Objavi spremembe',
published: 'Objavljeno',
publishIn: 'Objavi v {{locale}}',
publishing: 'Objavljanje',
restoreAsDraft: 'Obnovi kot osnutek',
restoredSuccessfully: 'Uspešno obnovljeno.',
restoreThisVersion: 'Obnovi to različico',
restoring: 'Obnavljanje...',
reverting: 'Razveljavljanje...',
revertToPublished: 'Vrni na objavljeno',
revertUnsuccessful: 'Razveljavitev ni uspela. Ni najdenih predhodno objavljenih verzij.',
saveDraft: 'Shrani osnutek',
scheduledSuccessfully: 'Uspešno načrtovano.',
schedulePublish: 'Razporedi objavo',
selectLocales: 'Izberite jezike za prikaz',
selectVersionToCompare: 'Izberite različico za primerjavo',
showingVersionsFor: 'Prikaz različic za:',
showLocales: 'Prikaži jezike:',
specificVersion: 'Specifična različica',
status: 'Status',
unpublish: 'Razveljavi objavo',
unpublished: 'Neobjavljeno',
unpublishedSuccessfully: 'Uspešno nepobjavljeno.',
unpublishIn: 'Prekliči objavo v {{locale}}',
unpublishing: 'Razveljavljanje objave...',
version: 'Različica',
versionAgo: 'pred {{distance}}',
versionCount_many: 'Najdenih {{count}} različic',
versionCount_none: 'Ni najdenih različic',
versionCount_one: 'Najdena {{count}} različica',
versionCount_other: 'Najdene {{count}} različice',
versionID: 'ID različice',
versions: 'Različice',
viewingVersion: 'Ogled različice za {{entityLabel}} {{documentTitle}}',
viewingVersionGlobal: 'Ogled različice za globalni {{entityLabel}}',
viewingVersions: 'Ogled različic za {{entityLabel}} {{documentTitle}}',
viewingVersionsGlobal: 'Ogled različic za globalni {{entityLabel}}'
}
};
export const sl = {
dateFNSKey: 'sl-SI',
translations: slTranslations
};
//# sourceMappingURL=sl.js.map

82
.pnpm-store/v10/files/51/412ce332db29d3d2eac5bc1237399be05312907164241cb19dbb6b6783f6e0afd7ae45ed4b3da46fdaecd16ebbb1fa82a5c664e1ec12f91d66b241b376e813 Normal file
View File

@@ -0,0 +1,82 @@
'use strict';
const packageData = require('../../package.json');
const shared = require('../shared');
/**
* Generates a Transport object to generate JSON output
*
* @constructor
* @param {Object} optional config parameter
*/
class JSONTransport {
constructor(options) {
options = options || {};
this.options = options || {};
this.name = 'JSONTransport';
this.version = packageData.version;
this.logger = shared.getLogger(this.options, {
component: this.options.component || 'json-transport'
});
}
/**
* <p>Compiles a mailcomposer message and forwards it to handler that sends it.</p>
*
* @param {Object} emailMessage MailComposer object
* @param {Function} callback Callback function to run when the sending is completed
*/
send(mail, done) {
// Sendmail strips this header line by itself
mail.message.keepBcc = true;
let envelope = mail.data.envelope || mail.message.getEnvelope();
let messageId = mail.message.messageId();
let recipients = [].concat(envelope.to || []);
if (recipients.length > 3) {
recipients.push('...and ' + recipients.splice(2).length + ' more');
}
this.logger.info(
{
tnx: 'send',
messageId
},
'Composing JSON structure of %s to <%s>',
messageId,
recipients.join(', ')
);
setImmediate(() => {
mail.normalize((err, data) => {
if (err) {
this.logger.error(
{
err,
tnx: 'send',
messageId
},
'Failed building JSON structure for %s. %s',
messageId,
err.message
);
return done(err);
}
delete data.envelope;
delete data.normalizedHeaders;
return done(null, {
envelope,
messageId,
message: this.options.skipEncoding ? data : JSON.stringify(data)
});
});
});
}
}
module.exports = JSONTransport;

32
.pnpm-store/v10/files/51/415ab22bcb6185f4ad1942235113c506bf0cff766d927da46e42cfdf9180a7e5f28c792cd7c6d7b0868fc56e392326a237ce0e9e222aeec7652bda14abf2a8 Normal file
View File

@@ -0,0 +1,32 @@
/**
* 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.
*
*/
import type { EditorConfig, KlassConstructor, LexicalEditor, Spread } from '../LexicalEditor';
import type { DOMConversionMap, DOMExportOutput, LexicalNode } from '../LexicalNode';
import type { RangeSelection } from '../LexicalSelection';
import type { SerializedElementNode } from './LexicalElementNode';
import { ElementNode } from './LexicalElementNode';
export type SerializedParagraphNode = Spread<{
textFormat: number;
textStyle: string;
}, SerializedElementNode>;
/** @noInheritDoc */
export declare class ParagraphNode extends ElementNode {
['constructor']: KlassConstructor<typeof ParagraphNode>;
static getType(): string;
static clone(node: ParagraphNode): ParagraphNode;
createDOM(config: EditorConfig): HTMLElement;
updateDOM(prevNode: ParagraphNode, dom: HTMLElement, config: EditorConfig): boolean;
static importDOM(): DOMConversionMap | null;
exportDOM(editor: LexicalEditor): DOMExportOutput;
static importJSON(serializedNode: SerializedParagraphNode): ParagraphNode;
exportJSON(): SerializedParagraphNode;
insertNewAfter(rangeSelection: RangeSelection, restoreSelection: boolean): ParagraphNode;
collapseAtStart(): boolean;
}
export declare function $createParagraphNode(): ParagraphNode;
export declare function $isParagraphNode(node: LexicalNode | null | undefined): node is ParagraphNode;

9
.pnpm-store/v10/files/51/42fc33551e9951cf24cbd39f66eb4b77ee756ec0157ebb1fd71e86d7ab270d2814c9e98a9dd5d3a152838e7b234e63cf759fb803dc63b0a04cb770e42d4f0b Normal file
View File

@@ -0,0 +1,9 @@
// This file is generated automatically by `scripts/build/fp.ts`. Please, don't change it.
import { nextDay as fn } from "../nextDay.js";
import { convertToFP } from "./_lib/convertToFP.js";
export const nextDay = convertToFP(fn, 2);
// Fallback for modularized imports:
export default nextDay;

1
.pnpm-store/v10/files/51/4419bc76864efce3f12337ba70ce1e48473455ae120665227c1fe82dfebcd07c17bfec3b3a297c1caf92148dfed8098bcbdb5bfaab7ba94208e33b97f415c7 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../../src/sqlite-core/query-builders/raw.ts"],"sourcesContent":["import { entityKind } from '~/entity.ts';\nimport { QueryPromise } from '~/query-promise.ts';\nimport type { RunnableQuery } from '~/runnable-query.ts';\nimport type { PreparedQuery } from '~/session.ts';\nimport type { SQL, SQLWrapper } from '~/sql/sql.ts';\nimport type { SQLiteAsyncDialect } from '../dialect.ts';\n\ntype SQLiteRawAction = 'all' | 'get' | 'values' | 'run';\nexport interface SQLiteRawConfig {\n\taction: SQLiteRawAction;\n}\n\nexport interface SQLiteRaw<TResult> extends QueryPromise<TResult>, RunnableQuery<TResult, 'sqlite'>, SQLWrapper {}\n\nexport class SQLiteRaw<TResult> extends QueryPromise<TResult>\n\timplements RunnableQuery<TResult, 'sqlite'>, SQLWrapper, PreparedQuery\n{\n\tstatic override readonly [entityKind]: string = 'SQLiteRaw';\n\n\tdeclare readonly _: {\n\t\treadonly dialect: 'sqlite';\n\t\treadonly result: TResult;\n\t};\n\n\t/** @internal */\n\tconfig: SQLiteRawConfig;\n\n\tconstructor(\n\t\tpublic execute: () => Promise<TResult>,\n\t\t/** @internal */\n\t\tpublic getSQL: () => SQL,\n\t\taction: SQLiteRawAction,\n\t\tprivate dialect: SQLiteAsyncDialect,\n\t\tprivate mapBatchResult: (result: unknown) => unknown,\n\t) {\n\t\tsuper();\n\t\tthis.config = { action };\n\t}\n\n\tgetQuery() {\n\t\treturn { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };\n\t}\n\n\tmapResult(result: unknown, isFromBatch?: boolean) {\n\t\treturn isFromBatch ? this.mapBatchResult(result) : result;\n\t}\n\n\t_prepare(): PreparedQuery {\n\t\treturn this;\n\t}\n\n\t/** @internal */\n\tisResponseInArrayMode(): boolean {\n\t\treturn false;\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA2B;AAC3B,2BAA6B;AAatB,MAAM,kBAA2B,kCAExC;AAAA,EAWC,YACQ,SAEA,QACP,QACQ,SACA,gBACP;AACD,UAAM;AAPC;AAEA;AAEC;AACA;AAGR,SAAK,SAAS,EAAE,OAAO;AAAA,EACxB;AAAA,EApBA,QAA0B,wBAAU,IAAY;AAAA;AAAA,EAQhD;AAAA,EAcA,WAAW;AACV,WAAO,EAAE,GAAG,KAAK,QAAQ,WAAW,KAAK,OAAO,CAAC,GAAG,QAAQ,KAAK,OAAO,OAAO;AAAA,EAChF;AAAA,EAEA,UAAU,QAAiB,aAAuB;AACjD,WAAO,cAAc,KAAK,eAAe,MAAM,IAAI;AAAA,EACpD;AAAA,EAEA,WAA0B;AACzB,WAAO;AAAA,EACR;AAAA;AAAA,EAGA,wBAAiC;AAChC,WAAO;AAAA,EACR;AACD;","names":[]}

64
.pnpm-store/v10/files/51/4628b3e6361b176827ab802ef8db68f60bae1ff6e565871e6796166cca0f4984e92c3d310577c4bc79ca4bae173bb3dee7eaf7cad0737f2d74403b5807e7f2 Normal file
View File

@@ -0,0 +1,64 @@
import type { Client, Connection, ExecutedQuery, Transaction } from '@planetscale/database';
import { type Cache } from "../cache/core/index.js";
import type { WithCacheConfig } from "../cache/core/types.js";
import { entityKind } from "../entity.js";
import type { Logger } from "../logger.js";
import type { MySqlDialect } from "../mysql-core/dialect.js";
import type { SelectedFieldsOrdered } from "../mysql-core/query-builders/select.types.js";
import { MySqlPreparedQuery, type MySqlPreparedQueryConfig, type MySqlPreparedQueryHKT, type MySqlQueryResultHKT, MySqlSession, MySqlTransaction } from "../mysql-core/session.js";
import type { RelationalSchemaConfig, TablesRelationalConfig } from "../relations.js";
import { type Query, type SQL } from "../sql/sql.js";
import { type Assume } from "../utils.js";
export declare class PlanetScalePreparedQuery<T extends MySqlPreparedQueryConfig> extends MySqlPreparedQuery<T> {
private client;
private queryString;
private params;
private logger;
private fields;
private customResultMapper?;
private generatedIds?;
private returningIds?;
static readonly [entityKind]: string;
private rawQuery;
private query;
constructor(client: Client | Transaction | Connection, queryString: string, params: unknown[], logger: Logger, cache: Cache, queryMetadata: {
type: 'select' | 'update' | 'delete' | 'insert';
tables: string[];
} | undefined, cacheConfig: WithCacheConfig | undefined, fields: SelectedFieldsOrdered | undefined, customResultMapper?: ((rows: unknown[][]) => T["execute"]) | undefined, generatedIds?: Record<string, unknown>[] | undefined, returningIds?: SelectedFieldsOrdered | undefined);
execute(placeholderValues?: Record<string, unknown> | undefined): Promise<T['execute']>;
iterator(_placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
}
export interface PlanetscaleSessionOptions {
logger?: Logger;
cache?: Cache;
}
export declare class PlanetscaleSession<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends MySqlSession<MySqlQueryResultHKT, PlanetScalePreparedQueryHKT, TFullSchema, TSchema> {
private baseClient;
private schema;
private options;
static readonly [entityKind]: string;
private logger;
private client;
private cache;
constructor(baseClient: Client | Connection, dialect: MySqlDialect, tx: Transaction | undefined, schema: RelationalSchemaConfig<TSchema> | undefined, options?: PlanetscaleSessionOptions);
prepareQuery<T extends MySqlPreparedQueryConfig = MySqlPreparedQueryConfig>(query: Query, fields: SelectedFieldsOrdered | undefined, customResultMapper?: (rows: unknown[][]) => T['execute'], generatedIds?: Record<string, unknown>[], returningIds?: SelectedFieldsOrdered, queryMetadata?: {
type: 'select' | 'update' | 'delete' | 'insert';
tables: string[];
}, cacheConfig?: WithCacheConfig): MySqlPreparedQuery<T>;
query(query: string, params: unknown[]): Promise<ExecutedQuery>;
queryObjects(query: string, params: unknown[]): Promise<ExecutedQuery>;
all<T = unknown>(query: SQL): Promise<T[]>;
count(sql: SQL): Promise<number>;
transaction<T>(transaction: (tx: PlanetScaleTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
}
export declare class PlanetScaleTransaction<TFullSchema extends Record<string, unknown>, TSchema extends TablesRelationalConfig> extends MySqlTransaction<PlanetscaleQueryResultHKT, PlanetScalePreparedQueryHKT, TFullSchema, TSchema> {
static readonly [entityKind]: string;
constructor(dialect: MySqlDialect, session: MySqlSession, schema: RelationalSchemaConfig<TSchema> | undefined, nestedIndex?: number);
transaction<T>(transaction: (tx: PlanetScaleTransaction<TFullSchema, TSchema>) => Promise<T>): Promise<T>;
}
export interface PlanetscaleQueryResultHKT extends MySqlQueryResultHKT {
type: ExecutedQuery;
}
export interface PlanetScalePreparedQueryHKT extends MySqlPreparedQueryHKT {
type: PlanetScalePreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
}

62
.pnpm-store/v10/files/51/46913ada02869f94ab262c354e8203dcdf5c231ab23e5137e114b5322879908b76e9d5d399b9b3430a8c6330989b2500e58834576ffa8245f0316de0a9bc92 Normal file
View File

@@ -0,0 +1,62 @@
import type { Scope } from '../scope';
import type { SpanLink } from './link';
import type { Span, SpanAttributes, SpanTimeInput } from './span';
export interface StartSpanOptions {
/** A manually specified start time for the created `Span` object. */
startTime?: SpanTimeInput;
/**
* If set, start the span on a fork of this scope instead of on the current scope.
* To ensure proper span cleanup, the passed scope is cloned for the duration of the span.
*
* If you want to modify the passed scope inside the callback, calling `getCurrentScope()`
* will return the cloned scope, meaning all scope modifications will be reset once the
* callback finishes
*
* If you want to modify the passed scope and have the changes persist after the callback ends,
* modify the scope directly instead of using `getCurrentScope()`
*/
scope?: Scope;
/** The name of the span. */
name: string;
/** If set to true, only start a span if a parent span exists. */
onlyIfParent?: boolean;
/** An op for the span. This is a categorization for spans. */
op?: string;
/**
* If provided, make the new span a child of this span.
* If this is not provided, the new span will be a child of the currently active span.
* If this is set to `null`, the new span will have no parent span.
*/
parentSpan?: Span | null;
/**
* If set to true, this span will be forced to be treated as a transaction in the Sentry UI, if possible and applicable.
* Note that it is up to the SDK to decide how exactly the span will be sent, which may change in future SDK versions.
* It is not guaranteed that a span started with this flag set to `true` will be sent as a transaction.
*/
forceTransaction?: boolean;
/** Attributes for the span. */
attributes?: SpanAttributes;
/**
* Links to associate with the new span. Setting links here is preferred over addLink()
* as it allows sampling decisions to consider the link information.
*/
links?: SpanLink[];
/**
* Experimental options without any stability guarantees. Use with caution!
*/
experimental?: {
/**
* If set to true, always start a standalone span which will be sent as a
* standalone segment span envelope instead of a transaction envelope.
*
* @internal this option is currently experimental and should only be
* used within SDK code. It might be removed or changed in the future.
* The payload ("envelope") of the resulting request sending the span to
* Sentry might change at any time.
*
* @hidden
*/
standalone?: boolean;
};
}
//# sourceMappingURL=startSpanOptions.d.ts.map

49
.pnpm-store/v10/files/51/49687427932087f0841fe36c6fcf7a0f561803e956d2bfbc41dfe074faa3e215a4bd0ce2bb9ae10fe0d6793da0c4d79e0a1b50be879b7e31f88c91a21271b8 Normal file
View File

@@ -0,0 +1,49 @@
var createPadding = require('./_createPadding'),
stringSize = require('./_stringSize'),
toInteger = require('./toInteger'),
toString = require('./toString');
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeCeil = Math.ceil,
nativeFloor = Math.floor;
/**
* Pads `string` on the left and right sides if it's shorter than `length`.
* Padding characters are truncated if they can't be evenly divided by `length`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to pad.
* @param {number} [length=0] The padding length.
* @param {string} [chars=' '] The string used as padding.
* @returns {string} Returns the padded string.
* @example
*
* _.pad('abc', 8);
* // => ' abc '
*
* _.pad('abc', 8, '_-');
* // => '_-abc_-_'
*
* _.pad('abc', 3);
* // => 'abc'
*/
function pad(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
if (!length || strLength >= length) {
return string;
}
var mid = (length - strLength) / 2;
return (
createPadding(nativeFloor(mid), chars) +
string +
createPadding(nativeCeil(mid), chars)
);
}
module.exports = pad;

188
.pnpm-store/v10/files/51/4a3004a6ea2fa0feae9f6c3d93c4c43a4072130a239bdb7c2a400a154d014b09f03d50dab75f0e3670b8f8ad32203e2796e8a53f001748ee779cafc4762f2d Normal file
View File

@@ -0,0 +1,188 @@
import { Breadcrumb } from '@sentry/core';
import { HistoryData, MemoryData, NavigationData, NetworkRequestData, PaintData, ResourceData, WebVitalData } from './performance';
import { ReplayEventTypeCustom } from './rrweb';
type AnyRecord = Record<string, any>;
interface ReplayBaseBreadcrumbFrame {
timestamp: number;
/**
* For compatibility reasons
*/
type: string;
category: string;
data?: AnyRecord;
message?: string;
}
interface ReplayBaseDomFrameData {
nodeId?: number;
node?: {
id: number;
tagName: string;
textContent: string;
attributes: AnyRecord;
};
}
interface ReplayConsoleFrameData {
logger: string;
arguments?: unknown[];
}
interface ReplayConsoleFrame extends ReplayBaseBreadcrumbFrame {
category: 'console';
level: Breadcrumb['level'];
message: string;
data: ReplayConsoleFrameData;
}
type ReplayClickFrameData = ReplayBaseDomFrameData;
interface ReplayClickFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.click';
message: string;
data: ReplayClickFrameData;
}
interface ReplayInputFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.input';
message: string;
}
interface ReplayMutationFrameData {
count: number;
limit: boolean;
}
interface ReplayMutationFrame extends ReplayBaseBreadcrumbFrame {
category: 'replay.mutations';
data: ReplayMutationFrameData;
}
interface ReplayHydrationErrorFrameData {
url: string;
}
interface ReplayHydrationErrorFrame extends ReplayBaseBreadcrumbFrame {
category: 'replay.hydrate-error';
data: ReplayHydrationErrorFrameData;
}
interface ReplayKeyboardEventFrameData extends ReplayBaseDomFrameData {
metaKey: boolean;
shiftKey: boolean;
ctrlKey: boolean;
altKey: boolean;
key: string;
}
interface ReplayKeyboardEventFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.keyDown';
data: ReplayKeyboardEventFrameData;
}
interface ReplayBlurFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.blur';
}
interface ReplayFocusFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.focus';
}
interface ReplaySlowClickFrameData extends ReplayClickFrameData {
url: string;
route?: string;
timeAfterClickMs: number;
endReason: string;
clickCount?: number;
}
export interface ReplaySlowClickFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.slowClickDetected';
data: ReplaySlowClickFrameData;
}
interface ReplayMultiClickFrameData extends ReplayClickFrameData {
url: string;
route?: string;
clickCount: number;
metric: true;
}
export interface ReplayMultiClickFrame extends ReplayBaseBreadcrumbFrame {
category: 'ui.multiClick';
data: ReplayMultiClickFrameData;
}
interface ReplayOptionFrame {
blockAllMedia: boolean;
errorSampleRate: number;
maskAllInputs: boolean;
maskAllText: boolean;
networkCaptureBodies: boolean;
networkDetailHasUrls: boolean;
networkRequestHasHeaders: boolean;
networkResponseHasHeaders: boolean;
sessionSampleRate: number;
shouldRecordCanvas: boolean;
useCompression: boolean;
useCompressionOption: boolean;
}
interface ReplayFeedbackFrameData {
feedbackId: string;
}
interface ReplayFeedbackFrame extends ReplayBaseBreadcrumbFrame {
category: 'sentry.feedback';
data: ReplayFeedbackFrameData;
}
export type ReplayBreadcrumbFrame = ReplayConsoleFrame | ReplayClickFrame | ReplayInputFrame | ReplayKeyboardEventFrame | ReplayBlurFrame | ReplayFocusFrame | ReplaySlowClickFrame | ReplayMultiClickFrame | ReplayMutationFrame | ReplayHydrationErrorFrame | ReplayFeedbackFrame | ReplayBaseBreadcrumbFrame;
interface ReplayBaseSpanFrame {
op: string;
description: string;
startTimestamp: number;
endTimestamp: number;
data?: undefined | AnyRecord;
}
interface ReplayHistoryFrame extends ReplayBaseSpanFrame {
data: HistoryData;
op: 'navigation.push';
}
interface ReplayWebVitalFrame extends ReplayBaseSpanFrame {
data: WebVitalData;
op: 'largest-contentful-paint' | 'cumulative-layout-shift' | 'interaction-to-next-paint';
}
interface ReplayMemoryFrame extends ReplayBaseSpanFrame {
data: MemoryData;
op: 'memory';
}
interface ReplayNavigationFrame extends ReplayBaseSpanFrame {
data: NavigationData;
op: 'navigation.navigate' | 'navigation.reload' | 'navigation.back_forward';
}
interface ReplayPaintFrame extends ReplayBaseSpanFrame {
data: PaintData;
op: 'paint';
}
interface ReplayRequestFrame extends ReplayBaseSpanFrame {
data: NetworkRequestData;
op: 'resource.fetch' | 'resource.xhr';
}
interface ReplayResourceFrame extends ReplayBaseSpanFrame {
data: ResourceData;
op: 'resource.css' | 'resource.iframe' | 'resource.img' | 'resource.link' | 'resource.other' | 'resource.script';
}
export type ReplaySpanFrame = ReplayBaseSpanFrame | ReplayHistoryFrame | ReplayRequestFrame | ReplayWebVitalFrame | ReplayMemoryFrame | ReplayNavigationFrame | ReplayPaintFrame | ReplayResourceFrame;
export type ReplayFrame = ReplayBreadcrumbFrame | ReplaySpanFrame;
interface RecordingCustomEvent {
type: typeof ReplayEventTypeCustom;
timestamp: number;
data: {
tag: string;
payload: unknown;
};
}
export interface ReplayBreadcrumbFrameEvent extends RecordingCustomEvent {
data: {
tag: 'breadcrumb';
payload: ReplayBreadcrumbFrame;
/**
* This will indicate to backend to additionally log as a metric
*/
metric?: boolean;
};
}
export interface ReplaySpanFrameEvent extends RecordingCustomEvent {
data: {
tag: 'performanceSpan';
payload: ReplaySpanFrame;
};
}
export interface ReplayOptionFrameEvent extends RecordingCustomEvent {
data: {
tag: 'options';
payload: ReplayOptionFrame;
};
}
export type ReplayFrameEvent = ReplayBreadcrumbFrameEvent | ReplaySpanFrameEvent | ReplayOptionFrameEvent;
export {};
//# sourceMappingURL=replayFrame.d.ts.map

61
.pnpm-store/v10/files/51/4af792a4d8ed8b9c806d0006ef31ef793742eb470f0ac7ceffe72307c81cfaedcd543a29fb61888745c6072b907e038dbb3d035752f480d04fbf046af75aba Normal file
View File

@@ -0,0 +1,61 @@
@import '../../../../scss/styles.scss';
@layer payload-default {
.live-preview-toolbar-controls {
display: flex;
align-items: center;
gap: calc(var(--base) / 3);
&__breakpoint {
border: none;
background: transparent;
height: var(--base);
&:focus {
outline: none;
}
}
&__device-size {
display: flex;
align-items: center;
}
&__size {
width: 50px;
height: var(--base);
display: flex;
align-items: center;
border: 1px solid var(--theme-elevation-200);
background: var(--theme-elevation-100);
border-radius: 2px;
font-size: small;
}
&__zoom {
width: 55px;
border: none;
background: transparent;
height: var(--base);
&:focus {
outline: none;
}
}
&__external {
flex-shrink: 0;
display: flex;
width: var(--base);
height: var(--base);
align-items: center;
justify-content: center;
padding: 6px 0;
}
.popup-button {
display: flex;
align-items: center;
}
}
}

45
.pnpm-store/v10/files/51/4c098e7716ce9bee4332a8aa2963d3d5b27c9c72b539da545d12fa82510baea056971f16ca21522cf3173da7138e6a435157667c1c02dd99e684382de3271f Normal file
View File

@@ -0,0 +1,45 @@
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
// src/body.tsx
import * as React from "react";
import { jsx } from "react/jsx-runtime";
var Body = React.forwardRef(
(_a, ref) => {
var _b = _a, { children, style } = _b, props = __objRest(_b, ["children", "style"]);
return /* @__PURE__ */ jsx("body", __spreadProps(__spreadValues({}, props), { ref, style, children }));
}
);
Body.displayName = "Body";
export {
Body
};

1
.pnpm-store/v10/files/51/4d777694521712ae3155eb5eddbf1149041a64caad3896f4d72a1a4f594e121f066f7da797f1ee8bd15dafa3e396843163e75c0a35aa4c5eebec3311e8a567 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/elements/Table/DefaultCell/fields/Checkbox/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAE7E,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,cAAc,CAAA;AAErB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CAAC,mBAAmB,CAAC,CAUjF,CAAA"}

17
.pnpm-store/v10/files/51/50cc81288f2e475ca324572c523e14ff008224ead1b295bbcfa1c07bea923e6a6c99db71b3d4e53f871d97b813a6c17837dd1516fe530f218f834257854203 Normal file
View File

@@ -0,0 +1,17 @@
/**
* @license lucide-react v0.441.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 MessageCirclePlus = createLucideIcon("MessageCirclePlus", [
["path", { d: "M7.9 20A9 9 0 1 0 4 16.1L2 22Z", key: "vv11sd" }],
["path", { d: "M8 12h8", key: "1wcyev" }],
["path", { d: "M12 8v8", key: "napkw2" }]
]);
export { MessageCirclePlus as default };
//# sourceMappingURL=message-circle-plus.js.map

28
.pnpm-store/v10/files/51/53444949158e7b89938e78469d03247bb3e92cd347c5f3ceb5280b89846dc5522447ab07808ee61ecc69b2c2d3b24ba7da4caaa00fa06a1b4759d52f9c1d25 Normal file
View File

@@ -0,0 +1,28 @@
import { HandlerDataFetch } from '../types-hoist/instrument';
/**
* Add an instrumentation handler for when a fetch request happens.
* The handler function is called once when the request starts and once when it ends,
* which can be identified by checking if it has an `endTimestamp`.
*
* Use at your own risk, this might break without changelog notice, only used internally.
* @hidden
*/
export declare function addFetchInstrumentationHandler(handler: (data: HandlerDataFetch) => void, skipNativeFetchCheck?: boolean): void;
/**
* Add an instrumentation handler for long-lived fetch requests, like consuming server-sent events (SSE) via fetch.
* The handler will resolve the request body and emit the actual `endTimestamp`, so that the
* span can be updated accordingly.
*
* Only used internally
* @hidden
*/
export declare function addFetchEndInstrumentationHandler(handler: (data: HandlerDataFetch) => void): void;
/**
* Parses the fetch arguments to find the used Http method and the url of the request.
* Exported for tests only.
*/
export declare function parseFetchArgs(fetchArgs: unknown[]): {
method: string;
url: string;
};
//# sourceMappingURL=fetch.d.ts.map

1
.pnpm-store/v10/files/51/5409d73aeabc7f771af290866479b33e5cc3eaac7fed0b6a163bc4a3798103f1b20e8bb683e8ff327bc66da8412505193916dea9911568a7ed368ab34faf5e Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"folder-edit.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

54
.pnpm-store/v10/files/51/55f4c6e5ab9afb8ceadf4e16c39e3aec2590aeb8122ab5b27d15b578df802bc5c801ed268a20d7d4a613b3f26e03c44d371c78b8cfb2e73b3eee17a261b4d0 Normal file
View File

@@ -0,0 +1,54 @@
import { WINDOW } from '../../../types.js';
import { addPageListener, removePageListener } from './globalListeners.js';
import { runOnce } from './runOnce.js';
/*
* Copyright 2024 Google LLC
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Runs the passed callback during the next idle period, or immediately
* if the browser's visibility state is (or becomes) hidden.
*/
const whenIdleOrHidden = (cb) => {
const rIC = WINDOW.requestIdleCallback || WINDOW.setTimeout;
// If the document is hidden, run the callback immediately, otherwise
// race an idle callback with the next `visibilitychange` event.
if (WINDOW.document?.visibilityState === 'hidden') {
cb();
} else {
// eslint-disable-next-line no-param-reassign
cb = runOnce(cb);
addPageListener('visibilitychange', cb, { once: true, capture: true });
// sentry: we use pagehide instead of directly listening to visibilitychange
// because some browsers we still support (Safari <14.4) don't fully support
// `visibilitychange` or have known bugs w.r.t the `visibilitychange` event.
// TODO(v11): remove this once we drop support for Safari <14.4
addPageListener('pagehide', cb, { once: true, capture: true });
rIC(() => {
cb();
// Remove the above event listener since no longer required.
// See: https://github.com/GoogleChrome/web-vitals/issues/622
removePageListener('visibilitychange', cb, { capture: true });
// TODO(v11): remove this once we drop support for Safari <14.4
removePageListener('pagehide', cb, { capture: true });
});
}
};
export { whenIdleOrHidden };
//# sourceMappingURL=whenIdleOrHidden.js.map

320
.pnpm-store/v10/files/51/5a1d5a5d90eff958dda03fb67d01f0a465f7c731a9d71313a594e001d0f6c9d6c7088e93c9a540e351d63d4ba6fadafdefacd547e75456dcfecfd6b826038b Normal file
View File

@@ -0,0 +1,320 @@
"use strict";
/*
* Copyright The OpenTelemetry Authors
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.SpanImpl = void 0;
const api_1 = require("@opentelemetry/api");
const core_1 = require("@opentelemetry/core");
const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
const enums_1 = require("./enums");
/**
* This class represents a span.
*/
class SpanImpl {
// Below properties are included to implement ReadableSpan for export
// purposes but are not intended to be written-to directly.
_spanContext;
kind;
parentSpanContext;
attributes = {};
links = [];
events = [];
startTime;
resource;
instrumentationScope;
_droppedAttributesCount = 0;
_droppedEventsCount = 0;
_droppedLinksCount = 0;
_attributesCount = 0;
name;
status = {
code: api_1.SpanStatusCode.UNSET,
};
endTime = [0, 0];
_ended = false;
_duration = [-1, -1];
_spanProcessor;
_spanLimits;
_attributeValueLengthLimit;
_performanceStartTime;
_performanceOffset;
_startTimeProvided;
/**
* Constructs a new SpanImpl instance.
*/
constructor(opts) {
const now = Date.now();
this._spanContext = opts.spanContext;
this._performanceStartTime = core_1.otperformance.now();
this._performanceOffset =
now - (this._performanceStartTime + core_1.otperformance.timeOrigin);
this._startTimeProvided = opts.startTime != null;
this._spanLimits = opts.spanLimits;
this._attributeValueLengthLimit =
this._spanLimits.attributeValueLengthLimit || 0;
this._spanProcessor = opts.spanProcessor;
this.name = opts.name;
this.parentSpanContext = opts.parentSpanContext;
this.kind = opts.kind;
this.links = opts.links || [];
this.startTime = this._getTime(opts.startTime ?? now);
this.resource = opts.resource;
this.instrumentationScope = opts.scope;
if (opts.attributes != null) {
this.setAttributes(opts.attributes);
}
this._spanProcessor.onStart(this, opts.context);
}
spanContext() {
return this._spanContext;
}
setAttribute(key, value) {
if (value == null || this._isSpanEnded())
return this;
if (key.length === 0) {
api_1.diag.warn(`Invalid attribute key: ${key}`);
return this;
}
if (!(0, core_1.isAttributeValue)(value)) {
api_1.diag.warn(`Invalid attribute value set for key: ${key}`);
return this;
}
const { attributeCountLimit } = this._spanLimits;
const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
if (attributeCountLimit !== undefined &&
this._attributesCount >= attributeCountLimit &&
isNewKey) {
this._droppedAttributesCount++;
return this;
}
this.attributes[key] = this._truncateToSize(value);
if (isNewKey) {
this._attributesCount++;
}
return this;
}
setAttributes(attributes) {
for (const [k, v] of Object.entries(attributes)) {
this.setAttribute(k, v);
}
return this;
}
/**
*
* @param name Span Name
* @param [attributesOrStartTime] Span attributes or start time
* if type is {@type TimeInput} and 3rd param is undefined
* @param [timeStamp] Specified time stamp for the event
*/
addEvent(name, attributesOrStartTime, timeStamp) {
if (this._isSpanEnded())
return this;
const { eventCountLimit } = this._spanLimits;
if (eventCountLimit === 0) {
api_1.diag.warn('No events allowed.');
this._droppedEventsCount++;
return this;
}
if (eventCountLimit !== undefined &&
this.events.length >= eventCountLimit) {
if (this._droppedEventsCount === 0) {
api_1.diag.debug('Dropping extra events.');
}
this.events.shift();
this._droppedEventsCount++;
}
if ((0, core_1.isTimeInput)(attributesOrStartTime)) {
if (!(0, core_1.isTimeInput)(timeStamp)) {
timeStamp = attributesOrStartTime;
}
attributesOrStartTime = undefined;
}
const attributes = (0, core_1.sanitizeAttributes)(attributesOrStartTime);
this.events.push({
name,
attributes,
time: this._getTime(timeStamp),
droppedAttributesCount: 0,
});
return this;
}
addLink(link) {
this.links.push(link);
return this;
}
addLinks(links) {
this.links.push(...links);
return this;
}
setStatus(status) {
if (this._isSpanEnded())
return this;
this.status = { ...status };
// When using try-catch, the caught "error" is of type `any`. When then assigning `any` to `status.message`,
// TypeScript will not error. While this can happen during use of any API, it is more common on Span#setStatus()
// as it's likely used in a catch-block. Therefore, we validate if `status.message` is actually a string, null, or
// undefined to avoid an incorrect type causing issues downstream.
if (this.status.message != null && typeof status.message !== 'string') {
api_1.diag.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
delete this.status.message;
}
return this;
}
updateName(name) {
if (this._isSpanEnded())
return this;
this.name = name;
return this;
}
end(endTime) {
if (this._isSpanEnded()) {
api_1.diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
return;
}
this.endTime = this._getTime(endTime);
this._duration = (0, core_1.hrTimeDuration)(this.startTime, this.endTime);
if (this._duration[0] < 0) {
api_1.diag.warn('Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.', this.startTime, this.endTime);
this.endTime = this.startTime.slice();
this._duration = [0, 0];
}
if (this._droppedEventsCount > 0) {
api_1.diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
}
if (this._spanProcessor.onEnding) {
this._spanProcessor.onEnding(this);
}
this._ended = true;
this._spanProcessor.onEnd(this);
}
_getTime(inp) {
if (typeof inp === 'number' && inp <= core_1.otperformance.now()) {
// must be a performance timestamp
// apply correction and convert to hrtime
return (0, core_1.hrTime)(inp + this._performanceOffset);
}
if (typeof inp === 'number') {
return (0, core_1.millisToHrTime)(inp);
}
if (inp instanceof Date) {
return (0, core_1.millisToHrTime)(inp.getTime());
}
if ((0, core_1.isTimeInputHrTime)(inp)) {
return inp;
}
if (this._startTimeProvided) {
// if user provided a time for the start manually
// we can't use duration to calculate event/end times
return (0, core_1.millisToHrTime)(Date.now());
}
const msDuration = core_1.otperformance.now() - this._performanceStartTime;
return (0, core_1.addHrTimes)(this.startTime, (0, core_1.millisToHrTime)(msDuration));
}
isRecording() {
return this._ended === false;
}
recordException(exception, time) {
const attributes = {};
if (typeof exception === 'string') {
attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE] = exception;
}
else if (exception) {
if (exception.code) {
attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] = exception.code.toString();
}
else if (exception.name) {
attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] = exception.name;
}
if (exception.message) {
attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE] = exception.message;
}
if (exception.stack) {
attributes[semantic_conventions_1.ATTR_EXCEPTION_STACKTRACE] = exception.stack;
}
}
// these are minimum requirements from spec
if (attributes[semantic_conventions_1.ATTR_EXCEPTION_TYPE] || attributes[semantic_conventions_1.ATTR_EXCEPTION_MESSAGE]) {
this.addEvent(enums_1.ExceptionEventName, attributes, time);
}
else {
api_1.diag.warn(`Failed to record an exception ${exception}`);
}
}
get duration() {
return this._duration;
}
get ended() {
return this._ended;
}
get droppedAttributesCount() {
return this._droppedAttributesCount;
}
get droppedEventsCount() {
return this._droppedEventsCount;
}
get droppedLinksCount() {
return this._droppedLinksCount;
}
_isSpanEnded() {
if (this._ended) {
const error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
api_1.diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
}
return this._ended;
}
// Utility function to truncate given value within size
// for value type of string, will truncate to given limit
// for type of non-string, will return same value
_truncateToLimitUtil(value, limit) {
if (value.length <= limit) {
return value;
}
return value.substring(0, limit);
}
/**
* If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
* return string with truncated to {@code attributeValueLengthLimit} characters
*
* If the given attribute value is array of strings then
* return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
*
* Otherwise return same Attribute {@code value}
*
* @param value Attribute value
* @returns truncated attribute value if required, otherwise same value
*/
_truncateToSize(value) {
const limit = this._attributeValueLengthLimit;
// Check limit
if (limit <= 0) {
// Negative values are invalid, so do not truncate
api_1.diag.warn(`Attribute value limit must be positive, got ${limit}`);
return value;
}
// String
if (typeof value === 'string') {
return this._truncateToLimitUtil(value, limit);
}
// Array of strings
if (Array.isArray(value)) {
return value.map(val => typeof val === 'string' ? this._truncateToLimitUtil(val, limit) : val);
}
// Other types, no need to apply value length limit
return value;
}
}
exports.SpanImpl = SpanImpl;
//# sourceMappingURL=Span.js.map

1
.pnpm-store/v10/files/51/5be7c879a90b916602049f07f3dca0538aa71111e03a12b2a80c2e693d923d26b3f947e4f790a646b4e4bd2f6a81ee1ee5ec01b4e51e2ba8e4101c1c4802d7 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/exports/templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAC1F,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,+BAA+B,CAAA"}

58
.pnpm-store/v10/files/51/5d2db4e442db90813de46874b31474d175c14d596bd77e1d7b76105c4d83d2f1881caf790e56ea78a79a205ee4bfdd17a66c30a6b68cd5ca3a9ebe8904f4d2 Normal file
View File

@@ -0,0 +1,58 @@
import type { BuildColumns } from "../column-builder.js";
import { entityKind } from "../entity.js";
import type { TypedQueryBuilder } from "../query-builders/query-builder.js";
import type { AddAliasToSelection } from "../query-builders/select.types.js";
import type { ColumnsSelection, SQL } from "../sql/sql.js";
import type { SQLiteColumnBuilderBase } from "./columns/common.js";
import { QueryBuilder } from "./query-builders/query-builder.js";
import { SQLiteViewBase } from "./view-base.js";
export interface ViewBuilderConfig {
algorithm?: 'undefined' | 'merge' | 'temptable';
definer?: string;
sqlSecurity?: 'definer' | 'invoker';
withCheckOption?: 'cascaded' | 'local';
}
export declare class ViewBuilderCore<TConfig extends {
name: string;
columns?: unknown;
}> {
protected name: TConfig['name'];
static readonly [entityKind]: string;
readonly _: {
readonly name: TConfig['name'];
readonly columns: TConfig['columns'];
};
constructor(name: TConfig['name']);
protected config: ViewBuilderConfig;
}
export declare class ViewBuilder<TName extends string = string> extends ViewBuilderCore<{
name: TName;
}> {
static readonly [entityKind]: string;
as<TSelection extends ColumnsSelection>(qb: TypedQueryBuilder<TSelection> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelection>)): SQLiteViewWithSelection<TName, false, AddAliasToSelection<TSelection, TName, 'sqlite'>>;
}
export declare class ManualViewBuilder<TName extends string = string, TColumns extends Record<string, SQLiteColumnBuilderBase> = Record<string, SQLiteColumnBuilderBase>> extends ViewBuilderCore<{
name: TName;
columns: TColumns;
}> {
static readonly [entityKind]: string;
private columns;
constructor(name: TName, columns: TColumns);
existing(): SQLiteViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'sqlite'>>;
as(query: SQL): SQLiteViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'sqlite'>>;
}
export declare class SQLiteView<TName extends string = string, TExisting extends boolean = boolean, TSelection extends ColumnsSelection = ColumnsSelection> extends SQLiteViewBase<TName, TExisting, TSelection> {
static readonly [entityKind]: string;
constructor({ config }: {
config: {
name: TName;
schema: string | undefined;
selectedFields: ColumnsSelection;
query: SQL | undefined;
};
});
}
export type SQLiteViewWithSelection<TName extends string, TExisting extends boolean, TSelection extends ColumnsSelection> = SQLiteView<TName, TExisting, TSelection> & TSelection;
export declare function sqliteView<TName extends string>(name: TName): ViewBuilder<TName>;
export declare function sqliteView<TName extends string, TColumns extends Record<string, SQLiteColumnBuilderBase>>(name: TName, columns: TColumns): ManualViewBuilder<TName, TColumns>;
export declare const view: typeof sqliteView;

15
.pnpm-store/v10/files/51/5f0e3a24d5bfc290b232f7200fc78b0be9b591d01f2195762fd6e2a9f20bcd864ce15daaf516ab400330fc159b1c0962f463f1956141fe556bda5cf061946b Normal file
View File

@@ -0,0 +1,15 @@
import { RestCommand } from "../../types.cjs";
//#region src/rest/commands/utils/sort.d.ts
/**
* If a collection has a sort field, this util can be used to move items in that manual order.
* @param collection The collection to sort
* @param item Id of the item to move
* @param to Id of the item to move to
* @returns Nothing
*/
declare const utilitySort: <Schema>(collection: keyof Schema, item: string | number, to: string | number) => RestCommand<void, Schema>;
//#endregion
export { utilitySort };
//# sourceMappingURL=sort.d.cts.map

279
.pnpm-store/v10/files/51/6006aca7d168d5bb6280d21ae610604e4d15460657d0948e69bb02ed9f321ce32667ea5d0aadd8061c4ff7b6ba3530f52986474f2b9f05da6b8b3b5d83da30 Normal file
View File

@@ -0,0 +1,279 @@
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.unload = exports.load = exports.onExit = exports.signals = void 0;
// Note: since nyc uses this module to output coverage, any lines
// that are in the direct sync flow of nyc's outputCoverage are
// ignored, since we can never get coverage for them.
// grab a reference to node's real process object right away
const signals_js_1 = require("./signals.js");
Object.defineProperty(exports, "signals", { enumerable: true, get: function () { return signals_js_1.signals; } });
const processOk = (process) => !!process &&
typeof process === 'object' &&
typeof process.removeListener === 'function' &&
typeof process.emit === 'function' &&
typeof process.reallyExit === 'function' &&
typeof process.listeners === 'function' &&
typeof process.kill === 'function' &&
typeof process.pid === 'number' &&
typeof process.on === 'function';
const kExitEmitter = Symbol.for('signal-exit emitter');
const global = globalThis;
const ObjectDefineProperty = Object.defineProperty.bind(Object);
// teeny special purpose ee
class Emitter {
emitted = {
afterExit: false,
exit: false,
};
listeners = {
afterExit: [],
exit: [],
};
count = 0;
id = Math.random();
constructor() {
if (global[kExitEmitter]) {
return global[kExitEmitter];
}
ObjectDefineProperty(global, kExitEmitter, {
value: this,
writable: false,
enumerable: false,
configurable: false,
});
}
on(ev, fn) {
this.listeners[ev].push(fn);
}
removeListener(ev, fn) {
const list = this.listeners[ev];
const i = list.indexOf(fn);
/* c8 ignore start */
if (i === -1) {
return;
}
/* c8 ignore stop */
if (i === 0 && list.length === 1) {
list.length = 0;
}
else {
list.splice(i, 1);
}
}
emit(ev, code, signal) {
if (this.emitted[ev]) {
return false;
}
this.emitted[ev] = true;
let ret = false;
for (const fn of this.listeners[ev]) {
ret = fn(code, signal) === true || ret;
}
if (ev === 'exit') {
ret = this.emit('afterExit', code, signal) || ret;
}
return ret;
}
}
class SignalExitBase {
}
const signalExitWrap = (handler) => {
return {
onExit(cb, opts) {
return handler.onExit(cb, opts);
},
load() {
return handler.load();
},
unload() {
return handler.unload();
},
};
};
class SignalExitFallback extends SignalExitBase {
onExit() {
return () => { };
}
load() { }
unload() { }
}
class SignalExit extends SignalExitBase {
// "SIGHUP" throws an `ENOSYS` error on Windows,
// so use a supported signal instead
/* c8 ignore start */
#hupSig = process.platform === 'win32' ? 'SIGINT' : 'SIGHUP';
/* c8 ignore stop */
#emitter = new Emitter();
#process;
#originalProcessEmit;
#originalProcessReallyExit;
#sigListeners = {};
#loaded = false;
constructor(process) {
super();
this.#process = process;
// { <signal>: <listener fn>, ... }
this.#sigListeners = {};
for (const sig of signals_js_1.signals) {
this.#sigListeners[sig] = () => {
// If there are no other listeners, an exit is coming!
// Simplest way: remove us and then re-send the signal.
// We know that this will kill the process, so we can
// safely emit now.
const listeners = this.#process.listeners(sig);
let { count } = this.#emitter;
// This is a workaround for the fact that signal-exit v3 and signal
// exit v4 are not aware of each other, and each will attempt to let
// the other handle it, so neither of them do. To correct this, we
// detect if we're the only handler *except* for previous versions
// of signal-exit, and increment by the count of listeners it has
// created.
/* c8 ignore start */
const p = process;
if (typeof p.__signal_exit_emitter__ === 'object' &&
typeof p.__signal_exit_emitter__.count === 'number') {
count += p.__signal_exit_emitter__.count;
}
/* c8 ignore stop */
if (listeners.length === count) {
this.unload();
const ret = this.#emitter.emit('exit', null, sig);
/* c8 ignore start */
const s = sig === 'SIGHUP' ? this.#hupSig : sig;
if (!ret)
process.kill(process.pid, s);
/* c8 ignore stop */
}
};
}
this.#originalProcessReallyExit = process.reallyExit;
this.#originalProcessEmit = process.emit;
}
onExit(cb, opts) {
/* c8 ignore start */
if (!processOk(this.#process)) {
return () => { };
}
/* c8 ignore stop */
if (this.#loaded === false) {
this.load();
}
const ev = opts?.alwaysLast ? 'afterExit' : 'exit';
this.#emitter.on(ev, cb);
return () => {
this.#emitter.removeListener(ev, cb);
if (this.#emitter.listeners['exit'].length === 0 &&
this.#emitter.listeners['afterExit'].length === 0) {
this.unload();
}
};
}
load() {
if (this.#loaded) {
return;
}
this.#loaded = true;
// This is the number of onSignalExit's that are in play.
// It's important so that we can count the correct number of
// listeners on signals, and don't wait for the other one to
// handle it instead of us.
this.#emitter.count += 1;
for (const sig of signals_js_1.signals) {
try {
const fn = this.#sigListeners[sig];
if (fn)
this.#process.on(sig, fn);
}
catch (_) { }
}
this.#process.emit = (ev, ...a) => {
return this.#processEmit(ev, ...a);
};
this.#process.reallyExit = (code) => {
return this.#processReallyExit(code);
};
}
unload() {
if (!this.#loaded) {
return;
}
this.#loaded = false;
signals_js_1.signals.forEach(sig => {
const listener = this.#sigListeners[sig];
/* c8 ignore start */
if (!listener) {
throw new Error('Listener not defined for signal: ' + sig);
}
/* c8 ignore stop */
try {
this.#process.removeListener(sig, listener);
/* c8 ignore start */
}
catch (_) { }
/* c8 ignore stop */
});
this.#process.emit = this.#originalProcessEmit;
this.#process.reallyExit = this.#originalProcessReallyExit;
this.#emitter.count -= 1;
}
#processReallyExit(code) {
/* c8 ignore start */
if (!processOk(this.#process)) {
return 0;
}
this.#process.exitCode = code || 0;
/* c8 ignore stop */
this.#emitter.emit('exit', this.#process.exitCode, null);
return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
}
#processEmit(ev, ...args) {
const og = this.#originalProcessEmit;
if (ev === 'exit' && processOk(this.#process)) {
if (typeof args[0] === 'number') {
this.#process.exitCode = args[0];
/* c8 ignore start */
}
/* c8 ignore start */
const ret = og.call(this.#process, ev, ...args);
/* c8 ignore start */
this.#emitter.emit('exit', this.#process.exitCode, null);
/* c8 ignore stop */
return ret;
}
else {
return og.call(this.#process, ev, ...args);
}
}
}
const process = globalThis.process;
// wrap so that we call the method on the actual handler, without
// exporting it directly.
_a = signalExitWrap(processOk(process) ? new SignalExit(process) : new SignalExitFallback()),
/**
* Called when the process is exiting, whether via signal, explicit
* exit, or running out of stuff to do.
*
* If the global process object is not suitable for instrumentation,
* then this will be a no-op.
*
* Returns a function that may be used to unload signal-exit.
*/
exports.onExit = _a.onExit,
/**
* Load the listeners. Likely you never need to call this, unless
* doing a rather deep integration with signal-exit functionality.
* Mostly exposed for the benefit of testing.
*
* @internal
*/
exports.load = _a.load,
/**
* Unload the listeners. Likely you never need to call this, unless
* doing a rather deep integration with signal-exit functionality.
* Mostly exposed for the benefit of testing.
*
* @internal
*/
exports.unload = _a.unload;
//# sourceMappingURL=index.js.map

1
.pnpm-store/v10/files/51/639439c1e44364a3932a86a853e383791e6b4dff639bff6f0d9f322e84cba634eca8b808b6a96bc6911c357e1c55dc53762590e826321524cbbab242dbcd31 Normal file
View File

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

1
.pnpm-store/v10/files/51/64a79ee9bcb3990b38eba6555bdcf972bbcbe02ccdb9da663f2d549b9aa5fd8052c810e370b2f4385e4fe0d92abd78d9de599f6c868e983d26353cfb87f384 Normal file
View File

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

25
.pnpm-store/v10/files/51/66140189c12bc0ace26d7c7457e84cdd77b94b295207ae4d70fd08dca366c55924c9f6bf7821992563444e06a4003cbff544c7c9022395452906909eb90a92 Normal file
View File

@@ -0,0 +1,25 @@
{
"name": "@types/parse-json",
"version": "4.0.2",
"description": "TypeScript definitions for parse-json",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/parse-json",
"license": "MIT",
"contributors": [
{
"name": "mrmlnc",
"githubUsername": "mrmlnc",
"url": "https://github.com/mrmlnc"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/parse-json"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "d1152b3b9b47f80db7e38510e7a49a297ca3c102317f67bcacb959271c65e6c1",
"typeScriptVersion": "4.5"
}

9297
.pnpm-store/v10/files/51/67b5cff38918845dfdee3b180b9efd65ce00f4421edc07fc1969b10a99bc93f1e563f0a0f9152f300a4cf67dc55b8dab9e4fee4d2001034b41cde073480eca Normal file
View File

File diff suppressed because it is too large Load Diff

703
.pnpm-store/v10/files/51/684e81e502a510fe7c4ae9ff910d859cdf0e87f0ecd92c0298c56de65df58caa58352ab2da5fd9faff0919648668afa72d88c854052fdb9a3a714aa31ff606 Normal file
View File

@@ -0,0 +1,703 @@
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const debugBuild = require('./debug-build.js');
const session = require('./session.js');
const debugLogger = require('./utils/debug-logger.js');
const is = require('./utils/is.js');
const merge = require('./utils/merge.js');
const misc = require('./utils/misc.js');
const propagationContext = require('./utils/propagationContext.js');
const randomSafeContext = require('./utils/randomSafeContext.js');
const spanOnScope = require('./utils/spanOnScope.js');
const string = require('./utils/string.js');
const time = require('./utils/time.js');
/**
* Default value for maximum number of breadcrumbs added to an event.
*/
const DEFAULT_MAX_BREADCRUMBS = 100;
/**
* A context to be used for capturing an event.
* This can either be a Scope, or a partial ScopeContext,
* or a callback that receives the current scope and returns a new scope to use.
*/
/**
* Holds additional event information.
*/
class Scope {
/** Flag if notifying is happening. */
/** Callback for client to receive scope changes. */
/** Callback list that will be called during event processing. */
/** Array of breadcrumbs. */
/** User */
/** Tags */
/** Attributes */
/** Extra */
/** Contexts */
/** Attachments */
/** Propagation Context for distributed tracing */
/**
* A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
* sent to Sentry
*/
/** Fingerprint */
/** Severity */
/**
* Transaction Name
*
* IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
* It's purpose is to assign a transaction to the scope that's added to non-transaction events.
*/
/** Session */
/** The client on this scope */
/** Contains the last event id of a captured event. */
/** Conversation ID */
// NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
constructor() {
this._notifyingListeners = false;
this._scopeListeners = [];
this._eventProcessors = [];
this._breadcrumbs = [];
this._attachments = [];
this._user = {};
this._tags = {};
this._attributes = {};
this._extra = {};
this._contexts = {};
this._sdkProcessingMetadata = {};
this._propagationContext = {
traceId: propagationContext.generateTraceId(),
sampleRand: randomSafeContext.safeMathRandom(),
};
}
/**
* Clone all data from this scope into a new scope.
*/
clone() {
const newScope = new Scope();
newScope._breadcrumbs = [...this._breadcrumbs];
newScope._tags = { ...this._tags };
newScope._attributes = { ...this._attributes };
newScope._extra = { ...this._extra };
newScope._contexts = { ...this._contexts };
if (this._contexts.flags) {
// We need to copy the `values` array so insertions on a cloned scope
// won't affect the original array.
newScope._contexts.flags = {
values: [...this._contexts.flags.values],
};
}
newScope._user = this._user;
newScope._level = this._level;
newScope._session = this._session;
newScope._transactionName = this._transactionName;
newScope._fingerprint = this._fingerprint;
newScope._eventProcessors = [...this._eventProcessors];
newScope._attachments = [...this._attachments];
newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };
newScope._propagationContext = { ...this._propagationContext };
newScope._client = this._client;
newScope._lastEventId = this._lastEventId;
newScope._conversationId = this._conversationId;
spanOnScope._setSpanForScope(newScope, spanOnScope._getSpanForScope(this));
return newScope;
}
/**
* Update the client assigned to this scope.
* Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,
* as well as manually created scopes.
*/
setClient(client) {
this._client = client;
}
/**
* Set the ID of the last captured error event.
* This is generally only captured on the isolation scope.
*/
setLastEventId(lastEventId) {
this._lastEventId = lastEventId;
}
/**
* Get the client assigned to this scope.
*/
getClient() {
return this._client ;
}
/**
* Get the ID of the last captured error event.
* This is generally only available on the isolation scope.
*/
lastEventId() {
return this._lastEventId;
}
/**
* @inheritDoc
*/
addScopeListener(callback) {
this._scopeListeners.push(callback);
}
/**
* Add an event processor that will be called before an event is sent.
*/
addEventProcessor(callback) {
this._eventProcessors.push(callback);
return this;
}
/**
* Set the user for this scope.
* Set to `null` to unset the user.
*/
setUser(user) {
// If null is passed we want to unset everything, but still define keys,
// so that later down in the pipeline any existing values are cleared.
this._user = user || {
email: undefined,
id: undefined,
ip_address: undefined,
username: undefined,
};
if (this._session) {
session.updateSession(this._session, { user });
}
this._notifyScopeListeners();
return this;
}
/**
* Get the user from this scope.
*/
getUser() {
return this._user;
}
/**
* Set the conversation ID for this scope.
* Set to `null` to unset the conversation ID.
*/
setConversationId(conversationId) {
this._conversationId = conversationId || undefined;
this._notifyScopeListeners();
return this;
}
/**
* Set an object that will be merged into existing tags on the scope,
* and will be sent as tags data with the event.
*/
setTags(tags) {
this._tags = {
...this._tags,
...tags,
};
this._notifyScopeListeners();
return this;
}
/**
* Set a single tag that will be sent as tags data with the event.
*/
setTag(key, value) {
return this.setTags({ [key]: value });
}
/**
* Sets attributes onto the scope.
*
* These attributes are currently applied to logs and metrics.
* In the future, they will also be applied to spans.
*
* Important: For now, only strings, numbers and boolean attributes are supported, despite types allowing for
* more complex attribute types. We'll add this support in the future but already specify the wider type to
* avoid a breaking change in the future.
*
* @param newAttributes - The attributes to set on the scope. You can either pass in key-value pairs, or
* an object with a `value` and an optional `unit` (if applicable to your attribute).
*
* @example
* ```typescript
* scope.setAttributes({
* is_admin: true,
* payment_selection: 'credit_card',
* render_duration: { value: 'render_duration', unit: 'ms' },
* });
* ```
*/
setAttributes(newAttributes) {
this._attributes = {
...this._attributes,
...newAttributes,
};
this._notifyScopeListeners();
return this;
}
/**
* Sets an attribute onto the scope.
*
* These attributes are currently applied to logs and metrics.
* In the future, they will also be applied to spans.
*
* Important: For now, only strings, numbers and boolean attributes are supported, despite types allowing for
* more complex attribute types. We'll add this support in the future but already specify the wider type to
* avoid a breaking change in the future.
*
* @param key - The attribute key.
* @param value - the attribute value. You can either pass in a raw value, or an attribute
* object with a `value` and an optional `unit` (if applicable to your attribute).
*
* @example
* ```typescript
* scope.setAttribute('is_admin', true);
* scope.setAttribute('render_duration', { value: 'render_duration', unit: 'ms' });
* ```
*/
// eslint-disable-next-line @typescript-eslint/no-explicit-any
setAttribute(
key,
value,
) {
return this.setAttributes({ [key]: value });
}
/**
* Removes the attribute with the given key from the scope.
*
* @param key - The attribute key.
*
* @example
* ```typescript
* scope.removeAttribute('is_admin');
* ```
*/
removeAttribute(key) {
if (key in this._attributes) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete this._attributes[key];
this._notifyScopeListeners();
}
return this;
}
/**
* Set an object that will be merged into existing extra on the scope,
* and will be sent as extra data with the event.
*/
setExtras(extras) {
this._extra = {
...this._extra,
...extras,
};
this._notifyScopeListeners();
return this;
}
/**
* Set a single key:value extra entry that will be sent as extra data with the event.
*/
setExtra(key, extra) {
this._extra = { ...this._extra, [key]: extra };
this._notifyScopeListeners();
return this;
}
/**
* Sets the fingerprint on the scope to send with the events.
* @param {string[]} fingerprint Fingerprint to group events in Sentry.
*/
setFingerprint(fingerprint) {
this._fingerprint = fingerprint;
this._notifyScopeListeners();
return this;
}
/**
* Sets the level on the scope for future events.
*/
setLevel(level) {
this._level = level;
this._notifyScopeListeners();
return this;
}
/**
* Sets the transaction name on the scope so that the name of e.g. taken server route or
* the page location is attached to future events.
*
* IMPORTANT: Calling this function does NOT change the name of the currently active
* root span. If you want to change the name of the active root span, use
* `Sentry.updateSpanName(rootSpan, 'new name')` instead.
*
* By default, the SDK updates the scope's transaction name automatically on sensible
* occasions, such as a page navigation or when handling a new request on the server.
*/
setTransactionName(name) {
this._transactionName = name;
this._notifyScopeListeners();
return this;
}
/**
* Sets context data with the given name.
* Data passed as context will be normalized. You can also pass `null` to unset the context.
* Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.
*/
setContext(key, context) {
if (context === null) {
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete this._contexts[key];
} else {
this._contexts[key] = context;
}
this._notifyScopeListeners();
return this;
}
/**
* Set the session for the scope.
*/
setSession(session) {
if (!session) {
delete this._session;
} else {
this._session = session;
}
this._notifyScopeListeners();
return this;
}
/**
* Get the session from the scope.
*/
getSession() {
return this._session;
}
/**
* Updates the scope with provided data. Can work in three variations:
* - plain object containing updatable attributes
* - Scope instance that'll extract the attributes from
* - callback function that'll receive the current scope as an argument and allow for modifications
*/
update(captureContext) {
if (!captureContext) {
return this;
}
const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;
const scopeInstance =
scopeToMerge instanceof Scope
? scopeToMerge.getScopeData()
: is.isPlainObject(scopeToMerge)
? (captureContext )
: undefined;
const {
tags,
attributes,
extra,
user,
contexts,
level,
fingerprint = [],
propagationContext,
conversationId,
} = scopeInstance || {};
this._tags = { ...this._tags, ...tags };
this._attributes = { ...this._attributes, ...attributes };
this._extra = { ...this._extra, ...extra };
this._contexts = { ...this._contexts, ...contexts };
if (user && Object.keys(user).length) {
this._user = user;
}
if (level) {
this._level = level;
}
if (fingerprint.length) {
this._fingerprint = fingerprint;
}
if (propagationContext) {
this._propagationContext = propagationContext;
}
if (conversationId) {
this._conversationId = conversationId;
}
return this;
}
/**
* Clears the current scope and resets its properties.
* Note: The client will not be cleared.
*/
clear() {
// client is not cleared here on purpose!
this._breadcrumbs = [];
this._tags = {};
this._attributes = {};
this._extra = {};
this._user = {};
this._contexts = {};
this._level = undefined;
this._transactionName = undefined;
this._fingerprint = undefined;
this._session = undefined;
this._conversationId = undefined;
spanOnScope._setSpanForScope(this, undefined);
this._attachments = [];
this.setPropagationContext({
traceId: propagationContext.generateTraceId(),
sampleRand: randomSafeContext.safeMathRandom(),
});
this._notifyScopeListeners();
return this;
}
/**
* Adds a breadcrumb to the scope.
* By default, the last 100 breadcrumbs are kept.
*/
addBreadcrumb(breadcrumb, maxBreadcrumbs) {
const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;
// No data has been changed, so don't notify scope listeners
if (maxCrumbs <= 0) {
return this;
}
const mergedBreadcrumb = {
timestamp: time.dateTimestampInSeconds(),
...breadcrumb,
// Breadcrumb messages can theoretically be infinitely large and they're held in memory so we truncate them not to leak (too much) memory
message: breadcrumb.message ? string.truncate(breadcrumb.message, 2048) : breadcrumb.message,
};
this._breadcrumbs.push(mergedBreadcrumb);
if (this._breadcrumbs.length > maxCrumbs) {
this._breadcrumbs = this._breadcrumbs.slice(-maxCrumbs);
this._client?.recordDroppedEvent('buffer_overflow', 'log_item');
}
this._notifyScopeListeners();
return this;
}
/**
* Get the last breadcrumb of the scope.
*/
getLastBreadcrumb() {
return this._breadcrumbs[this._breadcrumbs.length - 1];
}
/**
* Clear all breadcrumbs from the scope.
*/
clearBreadcrumbs() {
this._breadcrumbs = [];
this._notifyScopeListeners();
return this;
}
/**
* Add an attachment to the scope.
*/
addAttachment(attachment) {
this._attachments.push(attachment);
return this;
}
/**
* Clear all attachments from the scope.
*/
clearAttachments() {
this._attachments = [];
return this;
}
/**
* Get the data of this scope, which should be applied to an event during processing.
*/
getScopeData() {
return {
breadcrumbs: this._breadcrumbs,
attachments: this._attachments,
contexts: this._contexts,
tags: this._tags,
attributes: this._attributes,
extra: this._extra,
user: this._user,
level: this._level,
fingerprint: this._fingerprint || [],
eventProcessors: this._eventProcessors,
propagationContext: this._propagationContext,
sdkProcessingMetadata: this._sdkProcessingMetadata,
transactionName: this._transactionName,
span: spanOnScope._getSpanForScope(this),
conversationId: this._conversationId,
};
}
/**
* Add data which will be accessible during event processing but won't get sent to Sentry.
*/
setSDKProcessingMetadata(newData) {
this._sdkProcessingMetadata = merge.merge(this._sdkProcessingMetadata, newData, 2);
return this;
}
/**
* Add propagation context to the scope, used for distributed tracing
*/
setPropagationContext(context) {
this._propagationContext = context;
return this;
}
/**
* Get propagation context from the scope, used for distributed tracing
*/
getPropagationContext() {
return this._propagationContext;
}
/**
* Capture an exception for this scope.
*
* @returns {string} The id of the captured Sentry event.
*/
captureException(exception, hint) {
const eventId = hint?.event_id || misc.uuid4();
if (!this._client) {
debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture exception!');
return eventId;
}
const syntheticException = new Error('Sentry syntheticException');
this._client.captureException(
exception,
{
originalException: exception,
syntheticException,
...hint,
event_id: eventId,
},
this,
);
return eventId;
}
/**
* Capture a message for this scope.
*
* @returns {string} The id of the captured message.
*/
captureMessage(message, level, hint) {
const eventId = hint?.event_id || misc.uuid4();
if (!this._client) {
debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture message!');
return eventId;
}
const syntheticException = hint?.syntheticException ?? new Error(message);
this._client.captureMessage(
message,
level,
{
originalException: message,
syntheticException,
...hint,
event_id: eventId,
},
this,
);
return eventId;
}
/**
* Capture a Sentry event for this scope.
*
* @returns {string} The id of the captured event.
*/
captureEvent(event, hint) {
const eventId = event.event_id || hint?.event_id || misc.uuid4();
if (!this._client) {
debugBuild.DEBUG_BUILD && debugLogger.debug.warn('No client configured on scope - will not capture event!');
return eventId;
}
this._client.captureEvent(event, { ...hint, event_id: eventId }, this);
return eventId;
}
/**
* This will be called on every set call.
*/
_notifyScopeListeners() {
// We need this check for this._notifyingListeners to be able to work on scope during updates
// If this check is not here we'll produce endless recursion when something is done with the scope
// during the callback.
if (!this._notifyingListeners) {
this._notifyingListeners = true;
this._scopeListeners.forEach(callback => {
callback(this);
});
this._notifyingListeners = false;
}
}
}
exports.Scope = Scope;
//# sourceMappingURL=scope.js.map

49
.pnpm-store/v10/files/51/69dd4ab0b8b326608dc718cb0743ccf953af0312386ddc6bbfc9a8928220d6ee91dc3eff6218b75c832358f10513ef9acef43972fb72bc44869c3d02695767 Normal file
View File

@@ -0,0 +1,49 @@
import { ValueContainer } from './Ast';
import { MatcherFunction } from './Types';
/**
* Simple wrapper around the matcher function.
* Recommended return type for builder plugins.
*
* @typeParam L - the type of HTML Element in the targeted DOM AST.
* @typeParam V - the type of associated values.
*/
export declare class Picker<L, V> {
private f;
/**
* Create new Picker object.
*
* @typeParam L - the type of HTML Element in the targeted DOM AST.
* @typeParam V - the type of associated values.
*
* @param f - the function that matches an element
* and returns all associated values.
*/
constructor(f: MatcherFunction<L, V>);
/**
* Run the selectors decision tree against one HTML Element
* and return all matched associated values
* along with selector specificities.
*
* Client code then decides how to further process them
* (sort, filter, etc).
*
* @param el - an HTML Element.
*
* @returns all associated values along with
* selector specificities for all matched selectors.
*/
pickAll(el: L): ValueContainer<V>[];
/**
* Run the selectors decision tree against one HTML Element
* and choose the value from the most specific matched selector.
*
* @param el - an HTML Element.
*
* @param preferFirst - option to define which value to choose
* when there are multiple matches with equal specificity.
*
* @returns the value from the most specific matched selector
* or `null` if nothing matched.
*/
pick1(el: L, preferFirst?: boolean): V | null;
}

1
.pnpm-store/v10/files/51/6a0c62d87d7809ac2eff9a259d67df4d8af5670d424253e498a03a517b5b654393f717e2b2caeca003abd705792653f312561badd0a0ed075f3da41452733c Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"log-in.js","sources":["../../../src/icons/log-in.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name LogIn\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTUgM2g0YTIgMiAwIDAgMSAyIDJ2MTRhMiAyIDAgMCAxLTIgMmgtNCIgLz4KICA8cG9seWxpbmUgcG9pbnRzPSIxMCAxNyAxNSAxMiAxMCA3IiAvPgogIDxsaW5lIHgxPSIxNSIgeDI9IjMiIHkxPSIxMiIgeTI9IjEyIiAvPgo8L3N2Zz4K) - https://lucide.dev/icons/log-in\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 LogIn = createLucideIcon('LogIn', [\n ['path', { d: 'M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4', key: 'u53s6r' }],\n ['polyline', { points: '10 17 15 12 10 7', key: '1ail0h' }],\n ['line', { x1: '15', x2: '3', y1: '12', y2: '12', key: 'v6grx8' }],\n]);\n\nexport default LogIn;\n"],"names":[],"mappings":";;;;;;;;;AAaM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,iBAAiB,OAAS,CAAA,CAAA,CAAA;AAAA,CAAA,CACtC,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA6C,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA,CAAA;AAAA,CAAA,CAC1E,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAY,CAAA,CAAA,CAAA,CAAE,QAAQ,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,CAAA;AAAA,CAC1D,CAAA,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAE,CAAA,CAAA,CAAA,EAAI,CAAM,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAI,CAAK,CAAA,CAAA,CAAA,CAAA,EAAA,CAAI,CAAA,CAAA,CAAA,CAAA,CAAM,CAAA,CAAA,CAAA,CAAA,CAAI,CAAA,CAAA,CAAA,CAAA,CAAM,EAAA,CAAA,CAAA,CAAA,CAAA,CAAK,UAAU,CAAA;AACnE,CAAC,CAAA,CAAA;;"}

1
.pnpm-store/v10/files/51/6aa0183c54457ba1420ea4f51adc31dbfd60dd26caf7ca99944924aaf87829caf1087aac72572baaaac91896512e3280c3424dc6d58fe00fa9e0785228b9b0 Normal file
View File

File diff suppressed because one or more lines are too long

1
.pnpm-store/v10/files/51/6bc3f294a4579c6062dee2c2d06876a7fc7124b435ae25f90b8d18b2108943864dabae32cea2eeb4a134ff17c0ca30a438ca078e92ad86fade2e9af92fc5c0 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/Minimal/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,cAAc,CAAA;AAIrB,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IAC3B,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAU1D,CAAA"}

1
.pnpm-store/v10/files/51/6f9f51ec65147eab795541e5e3a08cc0f608afcec7aeb273143c34fba472912d1b23df9f0c711098cc9a8024e4b2a94cea53d67e397f43d7e3bd4d921c0cb9 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"context-api.js","sourceRoot":"","sources":["../../src/context-api.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,sEAAsE;AACtE,qCAAqC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,iCAAiC;AACjC,MAAM,CAAC,IAAM,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { ContextAPI } from './api/context';\n/** Entrypoint for context API */\nexport const context = ContextAPI.getInstance();\n"]}

2
.pnpm-store/v10/files/51/6fea21268a3311c5297aea4efbf63908dc6be366d5a37292096e9ee5374526da00b387a5d94d75c28c5405e6ddbb722f6253f63fab7d7fbe697058d7f89f1f Normal file
View File

@@ -0,0 +1,2 @@
import { bind } from "../fp";
export = bind;

298
.pnpm-store/v10/files/51/71bc7c263b529741357570b121cce1285b97e29dea133ad56d851bede072c6baac08fe76a47c8a3c0542db36a4d2e9780b1cf09b295800fe2d9bde18ba440b Normal file
View File

@@ -0,0 +1,298 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AssignmentExpression = AssignmentExpression;
exports.BinaryExpression = BinaryExpression;
exports.ClassExpression = ClassExpression;
exports.ArrowFunctionExpression = exports.ConditionalExpression = ConditionalExpression;
exports.DoExpression = DoExpression;
exports.FunctionExpression = FunctionExpression;
exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
exports.Identifier = Identifier;
exports.LogicalExpression = LogicalExpression;
exports.NullableTypeAnnotation = NullableTypeAnnotation;
exports.ObjectExpression = ObjectExpression;
exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
exports.OptionalCallExpression = exports.OptionalMemberExpression = OptionalMemberExpression;
exports.SequenceExpression = SequenceExpression;
exports.TSSatisfiesExpression = exports.TSAsExpression = TSAsExpression;
exports.TSConditionalType = TSConditionalType;
exports.TSConstructorType = exports.TSFunctionType = TSFunctionType;
exports.TSInferType = TSInferType;
exports.TSInstantiationExpression = TSInstantiationExpression;
exports.TSIntersectionType = TSIntersectionType;
exports.SpreadElement = exports.UnaryExpression = exports.TSTypeAssertion = UnaryLike;
exports.TSTypeOperator = TSTypeOperator;
exports.TSUnionType = TSUnionType;
exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation = UnionTypeAnnotation;
exports.UpdateExpression = UpdateExpression;
exports.AwaitExpression = exports.YieldExpression = YieldExpression;
var _t = require("@babel/types");
var _index = require("./index.js");
const {
isMemberExpression,
isOptionalMemberExpression,
isYieldExpression,
isStatement
} = _t;
const PRECEDENCE = new Map([["||", 0], ["??", 1], ["&&", 2], ["|", 3], ["^", 4], ["&", 5], ["==", 6], ["===", 6], ["!=", 6], ["!==", 6], ["<", 7], [">", 7], ["<=", 7], [">=", 7], ["in", 7], ["instanceof", 7], [">>", 8], ["<<", 8], [">>>", 8], ["+", 9], ["-", 9], ["*", 10], ["/", 10], ["%", 10], ["**", 11]]);
function isTSTypeExpression(nodeId) {
return nodeId === 156 || nodeId === 201 || nodeId === 209;
}
const isClassExtendsClause = (node, parent, parentId) => {
return (parentId === 21 || parentId === 22) && parent.superClass === node;
};
const hasPostfixPart = (node, parent, parentId) => {
switch (parentId) {
case 108:
case 132:
return parent.object === node;
case 17:
case 130:
case 112:
return parent.callee === node;
case 222:
return parent.tag === node;
case 191:
return true;
}
return false;
};
function NullableTypeAnnotation(node, parent, parentId) {
return parentId === 4;
}
function FunctionTypeAnnotation(node, parent, parentId, tokenContext) {
return (parentId === 239 || parentId === 90 || parentId === 4 || (tokenContext & _index.TokenContext.arrowFlowReturnType) > 0
);
}
function UpdateExpression(node, parent, parentId) {
return hasPostfixPart(node, parent, parentId) || isClassExtendsClause(node, parent, parentId);
}
function needsParenBeforeExpressionBrace(tokenContext) {
return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.arrowBody)) > 0;
}
function ObjectExpression(node, parent, parentId, tokenContext) {
return needsParenBeforeExpressionBrace(tokenContext);
}
function DoExpression(node, parent, parentId, tokenContext) {
return (tokenContext & _index.TokenContext.expressionStatement) > 0 && !node.async;
}
function BinaryLike(node, parent, parentId, nodeType) {
if (isClassExtendsClause(node, parent, parentId)) {
return true;
}
if (hasPostfixPart(node, parent, parentId) || parentId === 238 || parentId === 145 || parentId === 8) {
return true;
}
let parentPos;
switch (parentId) {
case 10:
case 107:
parentPos = PRECEDENCE.get(parent.operator);
break;
case 156:
case 201:
parentPos = 7;
}
if (parentPos !== undefined) {
const nodePos = nodeType === 2 ? 7 : PRECEDENCE.get(node.operator);
if (parentPos > nodePos) return true;
if (parentPos === nodePos && parentId === 10 && (nodePos === 11 ? parent.left === node : parent.right === node)) {
return true;
}
if (nodeType === 1 && parentId === 107 && (nodePos === 1 && parentPos !== 1 || parentPos === 1 && nodePos !== 1)) {
return true;
}
}
return false;
}
function UnionTypeAnnotation(node, parent, parentId) {
switch (parentId) {
case 4:
case 115:
case 90:
case 239:
return true;
}
return false;
}
function OptionalIndexedAccessType(node, parent, parentId) {
return parentId === 84 && parent.objectType === node;
}
function TSAsExpression(node, parent, parentId) {
if ((parentId === 6 || parentId === 7) && parent.left === node) {
return true;
}
if (parentId === 10 && (parent.operator === "|" || parent.operator === "&") && node === parent.left) {
return true;
}
return BinaryLike(node, parent, parentId, 2);
}
function TSConditionalType(node, parent, parentId) {
switch (parentId) {
case 155:
case 195:
case 211:
case 212:
return true;
case 175:
return parent.objectType === node;
case 181:
case 219:
return parent.types[0] === node;
case 161:
return parent.checkType === node || parent.extendsType === node;
}
return false;
}
function TSUnionType(node, parent, parentId) {
switch (parentId) {
case 181:
case 211:
case 155:
case 195:
return true;
case 175:
return parent.objectType === node;
}
return false;
}
function TSIntersectionType(node, parent, parentId) {
return parentId === 211 || TSTypeOperator(node, parent, parentId);
}
function TSInferType(node, parent, parentId) {
if (TSTypeOperator(node, parent, parentId)) {
return true;
}
if ((parentId === 181 || parentId === 219) && node.typeParameter.constraint && parent.types[0] === node) {
return true;
}
return false;
}
function TSTypeOperator(node, parent, parentId) {
switch (parentId) {
case 155:
case 195:
return true;
case 175:
if (parent.objectType === node) {
return true;
}
}
return false;
}
function TSInstantiationExpression(node, parent, parentId) {
switch (parentId) {
case 17:
case 130:
case 112:
case 177:
return (parent.typeParameters
) != null;
}
return false;
}
function TSFunctionType(node, parent, parentId) {
if (TSUnionType(node, parent, parentId)) return true;
return parentId === 219 || parentId === 161 && (parent.checkType === node || parent.extendsType === node);
}
function BinaryExpression(node, parent, parentId, tokenContext) {
if (BinaryLike(node, parent, parentId, 0)) return true;
return (tokenContext & _index.TokenContext.forInOrInitHeadAccumulate) > 0 && node.operator === "in";
}
function LogicalExpression(node, parent, parentId) {
return BinaryLike(node, parent, parentId, 1);
}
function SequenceExpression(node, parent, parentId) {
if (parentId === 144 || parentId === 133 || parentId === 108 && parent.property === node || parentId === 132 && parent.property === node || parentId === 224) {
return false;
}
if (parentId === 21) {
return true;
}
if (parentId === 68) {
return parent.right === node;
}
if (parentId === 60) {
return true;
}
return !isStatement(parent);
}
function YieldExpression(node, parent, parentId) {
return parentId === 10 || parentId === 107 || parentId === 238 || parentId === 145 || hasPostfixPart(node, parent, parentId) || parentId === 8 && isYieldExpression(node) || parentId === 28 && node === parent.test || isClassExtendsClause(node, parent, parentId) || isTSTypeExpression(parentId);
}
function ClassExpression(node, parent, parentId, tokenContext) {
return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
}
function UnaryLike(node, parent, parentId) {
return hasPostfixPart(node, parent, parentId) || parentId === 10 && parent.operator === "**" && parent.left === node || isClassExtendsClause(node, parent, parentId);
}
function FunctionExpression(node, parent, parentId, tokenContext) {
return (tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.exportDefault)) > 0;
}
function ConditionalExpression(node, parent, parentId) {
switch (parentId) {
case 238:
case 145:
case 10:
case 107:
case 8:
return true;
case 28:
if (parent.test === node) {
return true;
}
}
if (isTSTypeExpression(parentId)) {
return true;
}
return UnaryLike(node, parent, parentId);
}
function OptionalMemberExpression(node, parent, parentId) {
switch (parentId) {
case 17:
return parent.callee === node;
case 108:
return parent.object === node;
}
return false;
}
function AssignmentExpression(node, parent, parentId, tokenContext) {
if (needsParenBeforeExpressionBrace(tokenContext) && node.left.type === "ObjectPattern") {
return true;
}
return ConditionalExpression(node, parent, parentId);
}
function Identifier(node, parent, parentId, tokenContext, getRawIdentifier) {
var _node$extra;
if (getRawIdentifier && getRawIdentifier(node) !== node.name) {
return false;
}
if (parentId === 6 && (_node$extra = node.extra) != null && _node$extra.parenthesized && parent.left === node) {
const rightType = parent.right.type;
if ((rightType === "FunctionExpression" || rightType === "ClassExpression") && parent.right.id == null) {
return true;
}
}
if (tokenContext & _index.TokenContext.forOfHead || (parentId === 108 || parentId === 132) && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
if (node.name === "let") {
const isFollowedByBracket = isMemberExpression(parent, {
object: node,
computed: true
}) || isOptionalMemberExpression(parent, {
object: node,
computed: true,
optional: false
});
if (isFollowedByBracket && tokenContext & (_index.TokenContext.expressionStatement | _index.TokenContext.forInitHead | _index.TokenContext.forInHead)) {
return true;
}
return (tokenContext & _index.TokenContext.forOfHead) > 0;
}
}
return parentId === 68 && parent.left === node && node.name === "async" && !parent.await;
}
//# sourceMappingURL=parentheses.js.map

9
.pnpm-store/v10/files/51/71d09fb11479f781e7b2ec2190ecd356a2a56ae15cb60eb774e25ced9ad5acc355026d62bb559b501618ea6726d15db3b95bce38cd61c1e2eb2341809f579c Normal file
View File

@@ -0,0 +1,9 @@
// This file is generated automatically by `scripts/build/fp.ts`. Please, don't change it.
import { isSameQuarter as fn } from "../isSameQuarter.js";
import { convertToFP } from "./_lib/convertToFP.js";
export const isSameQuarter = convertToFP(fn, 2);
// Fallback for modularized imports:
export default isSameQuarter;

36
.pnpm-store/v10/files/51/7634378c05593f7cae1800d9b8d2b1c50efabd6a96495aaaf7db4eef7727549d99408e3efd7db320415626f93a55524154cbe9d3f7f154a950c561e4a08988 Normal file
View File

@@ -0,0 +1,36 @@
import { normalizeDates } from "./_lib/normalizeDates.js";
/**
* The {@link isSameYear} function options.
*/
/**
* @name isSameYear
* @category Year Helpers
* @summary Are the given dates in the same year?
*
* @description
* Are the given dates in the same year?
*
* @param laterDate - The first date to check
* @param earlierDate - The second date to check
* @param options - An object with options
*
* @returns The dates are in the same year
*
* @example
* // Are 2 September 2014 and 25 September 2014 in the same year?
* const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))
* //=> true
*/
export function isSameYear(laterDate, earlierDate, options) {
const [laterDate_, earlierDate_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
return laterDate_.getFullYear() === earlierDate_.getFullYear();
}
// Fallback for modularized imports:
export default isSameYear;

2
.pnpm-store/v10/files/51/779a3304f6ccf3617080994e22e647d4966a5f68716fa8e1ec8c6ceaaa4399d5d901c1acf3e35920f4614a088f6dc542b9f7d7427711ee12f463cf95e54343 Normal file
View File

@@ -0,0 +1,2 @@
import { rangeStep } from "../fp";
export = rangeStep;

28
.pnpm-store/v10/files/51/78620ebbfa7f49917b7e5727b1fdfbcf4fbcae51fd8950f8e9cbc790f82c46ae708b36e23dc6c2b6272398091fca6d74e5c0ea3deaed636c75f97860f5b939 Normal file
View File

@@ -0,0 +1,28 @@
"use strict";
exports.pt = void 0;
var _index = require("./pt/_lib/formatDistance.js");
var _index2 = require("./pt/_lib/formatLong.js");
var _index3 = require("./pt/_lib/formatRelative.js");
var _index4 = require("./pt/_lib/localize.js");
var _index5 = require("./pt/_lib/match.js");
/**
* @category Locales
* @summary Portuguese locale.
* @language Portuguese
* @iso-639-2 por
* @author Dário Freire [@dfreire](https://github.com/dfreire)
* @author Adrián de la Rosa [@adrm](https://github.com/adrm)
*/
const pt = (exports.pt = {
code: "pt",
formatDistance: _index.formatDistance,
formatLong: _index2.formatLong,
formatRelative: _index3.formatRelative,
localize: _index4.localize,
match: _index5.match,
options: {
weekStartsOn: 1 /* Monday */,
firstWeekContainsDate: 4,
},
});

9
.pnpm-store/v10/files/51/78a730237127169253f33767dff2070757ab1c875e8cd0510f7d612c8485cde7f42d115f6c6b4458a69d7c5e9e24d768f76c0e9c7c623608593e6a65a5e59b Normal file
View File

@@ -0,0 +1,9 @@
/**
* 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.
*
*/
import type { LexicalEditor } from 'lexical';
export declare function useCanShowPlaceholder(editor: LexicalEditor): boolean;

103
.pnpm-store/v10/files/51/79e6a0d4e7f543ea85e40e10d159723587c5f1098706269f9807ae24703ad61bb5772f7cee8a5030bcf6008b1a8bca904faaa50aa08acba7b1974a72a5e894 Normal file
View File

@@ -0,0 +1,103 @@
'use strict';
var reactIs = require('react-is');
/**
* Copyright 2015, Yahoo! Inc.
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var REACT_STATICS = {
childContextTypes: true,
contextType: true,
contextTypes: true,
defaultProps: true,
displayName: true,
getDefaultProps: true,
getDerivedStateFromError: true,
getDerivedStateFromProps: true,
mixins: true,
propTypes: true,
type: true
};
var KNOWN_STATICS = {
name: true,
length: true,
prototype: true,
caller: true,
callee: true,
arguments: true,
arity: true
};
var FORWARD_REF_STATICS = {
'$$typeof': true,
render: true,
defaultProps: true,
displayName: true,
propTypes: true
};
var MEMO_STATICS = {
'$$typeof': true,
compare: true,
defaultProps: true,
displayName: true,
propTypes: true,
type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
// React v16.11 and below
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
} // React v16.12 and above
return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}
var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
if (typeof sourceComponent !== 'string') {
// don't hoist over string (html) components
if (objectPrototype) {
var inheritedComponent = getPrototypeOf(sourceComponent);
if (inheritedComponent && inheritedComponent !== objectPrototype) {
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
}
}
var keys = getOwnPropertyNames(sourceComponent);
if (getOwnPropertySymbols) {
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
}
var targetStatics = getStatics(targetComponent);
var sourceStatics = getStatics(sourceComponent);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
// Avoid failures from read-only properties
defineProperty(targetComponent, key, descriptor);
} catch (e) {}
}
}
}
return targetComponent;
}
module.exports = hoistNonReactStatics;

1934
.pnpm-store/v10/files/51/79ff8796f010ce82781dc4be07cf6ab3428aceb91b08d270ef34f6f7044e57cf9befb84d1c26451bfbe04b447690573285e834cd88d22c9ad83cfe51df17ee Normal file
View File

File diff suppressed because it is too large Load Diff

16
.pnpm-store/v10/files/51/7adcf0eb532ec1bf23a1ab9d24cf7a1dc0a638a64a750c993595c9acac3ebf2bbff8229a685ebff3889bc7105e39f208ff06d18378c52183bd954469cf6af4 Normal file
View File

@@ -0,0 +1,16 @@
/**
* @license lucide-react v0.441.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 ArrowDownLeft = createLucideIcon("ArrowDownLeft", [
["path", { d: "M17 7 7 17", key: "15tmo1" }],
["path", { d: "M17 17H7V7", key: "1org7z" }]
]);
export { ArrowDownLeft as default };
//# sourceMappingURL=arrow-down-left.js.map

53
.pnpm-store/v10/files/51/7d986b7745cfa69bc4f31f203a16b4c3a145810cec187ba9b8ce3c3a7b8fc426b785f2641f80eeebe906d21af09f2a0aa109fc577fc864111e12fb3e43f2d7 Normal file
View File

@@ -0,0 +1,53 @@
import { Parser } from "../Parser.mjs";
import { dayPeriodEnumToHours } from "../utils.mjs";
export class AMPMParser extends Parser {
priority = 80;
parse(dateString, token, match) {
switch (token) {
case "a":
case "aa":
case "aaa":
return (
match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting",
}) ||
match.dayPeriod(dateString, {
width: "narrow",
context: "formatting",
})
);
case "aaaaa":
return match.dayPeriod(dateString, {
width: "narrow",
context: "formatting",
});
case "aaaa":
default:
return (
match.dayPeriod(dateString, {
width: "wide",
context: "formatting",
}) ||
match.dayPeriod(dateString, {
width: "abbreviated",
context: "formatting",
}) ||
match.dayPeriod(dateString, {
width: "narrow",
context: "formatting",
})
);
}
}
set(date, _flags, value) {
date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
return date;
}
incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
}

1
.pnpm-store/v10/files/51/7e0e18a1423e268ca9cabf3662c538ac51817b2044306ff30ab6a04a2815cbeaabb9b2b58967ed4bf82b8a32369af04d8bedff08276a3d9ff88a684e8cdf3b Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/ConfirmationModal/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAsB,MAAM,OAAO,CAAA;AAK1C,OAAO,cAAc,CAAA;AAIrB,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAA;AAEjC,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,KAAK,CAAC,SAAS,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,KAAK,CAAC,SAAS,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACtC,CAAA;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,qBAkF9D"}

7
.pnpm-store/v10/files/51/7e3de69bb164f35dd926449d4a24bd673a9eccda7f81c56bc199cb59ed7e0b9a53afe94de4fe24040947ac6ee28b9f9902bc0e01b612b8b87e419a7e587a77 Normal file
View File

File diff suppressed because one or more lines are too long

9
.pnpm-store/v10/files/51/7e8dc0f5dc487e4e3acfa763a68cd99f0c27178f20d2cf082230a7eec694fa0c6d1291f0834719195e9ceed368ca7096241e262d33ec3c11efdad4bfa3f0d5 Normal file
View File

@@ -0,0 +1,9 @@
//#region src/rest/utils/get-auth-endpoint.d.ts
/**
* @param provider Use a specific authentication provider
* @returns The endpoint to be used for authentication
*/
declare function getAuthEndpoint(provider?: string): string;
//#endregion
export { getAuthEndpoint };
//# sourceMappingURL=get-auth-endpoint.d.cts.map

123
.pnpm-store/v10/files/51/7f165e2bec1040a045e18d009e0e2c7a20231ca3399cbd15283f0b7fcbe72aa08fb8a3893cfdc9de89a4f31c7f525d8f4e2c7187efac637f21281e60e6dbfe Normal file
View File

@@ -0,0 +1,123 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.listStyleType = void 0;
exports.listStyleType = {
name: 'list-style-type',
initialValue: 'none',
prefix: false,
type: 2 /* IDENT_VALUE */,
parse: function (_context, type) {
switch (type) {
case 'disc':
return 0 /* DISC */;
case 'circle':
return 1 /* CIRCLE */;
case 'square':
return 2 /* SQUARE */;
case 'decimal':
return 3 /* DECIMAL */;
case 'cjk-decimal':
return 4 /* CJK_DECIMAL */;
case 'decimal-leading-zero':
return 5 /* DECIMAL_LEADING_ZERO */;
case 'lower-roman':
return 6 /* LOWER_ROMAN */;
case 'upper-roman':
return 7 /* UPPER_ROMAN */;
case 'lower-greek':
return 8 /* LOWER_GREEK */;
case 'lower-alpha':
return 9 /* LOWER_ALPHA */;
case 'upper-alpha':
return 10 /* UPPER_ALPHA */;
case 'arabic-indic':
return 11 /* ARABIC_INDIC */;
case 'armenian':
return 12 /* ARMENIAN */;
case 'bengali':
return 13 /* BENGALI */;
case 'cambodian':
return 14 /* CAMBODIAN */;
case 'cjk-earthly-branch':
return 15 /* CJK_EARTHLY_BRANCH */;
case 'cjk-heavenly-stem':
return 16 /* CJK_HEAVENLY_STEM */;
case 'cjk-ideographic':
return 17 /* CJK_IDEOGRAPHIC */;
case 'devanagari':
return 18 /* DEVANAGARI */;
case 'ethiopic-numeric':
return 19 /* ETHIOPIC_NUMERIC */;
case 'georgian':
return 20 /* GEORGIAN */;
case 'gujarati':
return 21 /* GUJARATI */;
case 'gurmukhi':
return 22 /* GURMUKHI */;
case 'hebrew':
return 22 /* HEBREW */;
case 'hiragana':
return 23 /* HIRAGANA */;
case 'hiragana-iroha':
return 24 /* HIRAGANA_IROHA */;
case 'japanese-formal':
return 25 /* JAPANESE_FORMAL */;
case 'japanese-informal':
return 26 /* JAPANESE_INFORMAL */;
case 'kannada':
return 27 /* KANNADA */;
case 'katakana':
return 28 /* KATAKANA */;
case 'katakana-iroha':
return 29 /* KATAKANA_IROHA */;
case 'khmer':
return 30 /* KHMER */;
case 'korean-hangul-formal':
return 31 /* KOREAN_HANGUL_FORMAL */;
case 'korean-hanja-formal':
return 32 /* KOREAN_HANJA_FORMAL */;
case 'korean-hanja-informal':
return 33 /* KOREAN_HANJA_INFORMAL */;
case 'lao':
return 34 /* LAO */;
case 'lower-armenian':
return 35 /* LOWER_ARMENIAN */;
case 'malayalam':
return 36 /* MALAYALAM */;
case 'mongolian':
return 37 /* MONGOLIAN */;
case 'myanmar':
return 38 /* MYANMAR */;
case 'oriya':
return 39 /* ORIYA */;
case 'persian':
return 40 /* PERSIAN */;
case 'simp-chinese-formal':
return 41 /* SIMP_CHINESE_FORMAL */;
case 'simp-chinese-informal':
return 42 /* SIMP_CHINESE_INFORMAL */;
case 'tamil':
return 43 /* TAMIL */;
case 'telugu':
return 44 /* TELUGU */;
case 'thai':
return 45 /* THAI */;
case 'tibetan':
return 46 /* TIBETAN */;
case 'trad-chinese-formal':
return 47 /* TRAD_CHINESE_FORMAL */;
case 'trad-chinese-informal':
return 48 /* TRAD_CHINESE_INFORMAL */;
case 'upper-armenian':
return 49 /* UPPER_ARMENIAN */;
case 'disclosure-open':
return 50 /* DISCLOSURE_OPEN */;
case 'disclosure-closed':
return 51 /* DISCLOSURE_CLOSED */;
case 'none':
default:
return -1 /* NONE */;
}
}
};
//# sourceMappingURL=list-style-type.js.map

2
.pnpm-store/v10/files/51/805bc62904351e5b1c5b9eb881ff66f574418a000aba84f67d16da65accbd8af91a5628fe01cb5a67a25f500f6d92a5b5ce1929332fbad269cc51468d3e731 Normal file
View File

@@ -0,0 +1,2 @@
import { tap } from "./index";
export = tap;

18
.pnpm-store/v10/files/51/8113037ee03540caae63058a98525f9a4a67425bd8c3596f697bed5ae1d2053fe76f76b85a4eefb80cc519f7b03d368cf4b445288c4ca7cacb5e7523f33962 Normal file
View File

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

158
.pnpm-store/v10/files/51/8a3469510fa8573fc8038bbb2c0bcea5fa7c0f546f11cbc432397c0ce4abd671ff0a9b4952011813e79c65eab4b6dcc86524f5fdbd58c89040319a4966ee1b Normal file
View File

@@ -0,0 +1,158 @@
import { type SupportedLanguages } from '@payloadcms/translations';
import type { SanitizedDocumentPermissions } from '../../auth/types.js';
import type { Field, Option, TabAsField, Validate } from '../../fields/config/types.js';
import type { TypedLocale } from '../../index.js';
import type { DocumentPreferences } from '../../preferences/types.js';
import type { PayloadRequest, SelectType, Where } from '../../types/index.js';
export type Data = {
[key: string]: any;
};
export type Row = {
addedByServer?: FieldState['addedByServer'];
blockType?: string;
collapsed?: boolean;
customComponents?: {
RowLabel?: React.ReactNode;
};
id: string;
isLoading?: boolean;
lastRenderedPath?: string;
};
export type FilterOptionsResult = {
[relation: string]: boolean | Where;
};
export type FieldState = {
/**
* This is used to determine if the field was added by the server.
* This ensures the field is not ignored by the client when merging form state.
* This can happen because the current local state is treated as the source of truth.
* See `mergeServerFormState` for more details.
*/
addedByServer?: boolean;
/**
* If the field is a `blocks` field, this will contain the slugs of blocks that are allowed, based on the result of `field.filterOptions`.
* If this is undefined, all blocks are allowed.
* If this is an empty array, no blocks are allowed.
*/
blocksFilterOptions?: string[];
customComponents?: {
/**
* This is used by UI fields, as they can have arbitrary components defined if used
* as a vessel to bring in custom components.
*/
[key: string]: React.ReactNode | React.ReactNode[] | undefined;
AfterInput?: React.ReactNode;
BeforeInput?: React.ReactNode;
Description?: React.ReactNode;
Error?: React.ReactNode;
Field?: React.ReactNode;
Label?: React.ReactNode;
};
disableFormData?: boolean;
errorMessage?: string;
errorPaths?: string[];
/**
* The fieldSchema may be part of the form state if `includeSchema: true` is passed to buildFormState.
* This will never be in the form state of the client.
*/
fieldSchema?: Field | TabAsField;
filterOptions?: FilterOptionsResult;
initialValue?: unknown;
/**
* Every time a field is changed locally, this flag is set to true. Prevents form state from server from overwriting local changes.
* After merging server form state, this flag is reset.
*
* @experimental This property is experimental and may change in the future. Use at your own risk.
*/
isModified?: boolean;
/**
* The path of the field when its custom components were last rendered.
* This is used to denote if a field has been rendered, and if so,
* what path it was rendered under last.
*
* If this path is undefined, or, if it is different
* from the current path of a given field, the field's components will be re-rendered.
*/
lastRenderedPath?: string;
passesCondition?: boolean;
rows?: Row[];
/**
* The result of running `field.filterOptions` on select fields.
*/
selectFilterOptions?: Option[];
valid?: boolean;
validate?: Validate;
value?: unknown;
};
export type FieldStateWithoutComponents = Omit<FieldState, 'customComponents'>;
export type FormState = {
[path: string]: FieldState;
};
export type FormStateWithoutComponents = {
[path: string]: FieldStateWithoutComponents;
};
export type BuildFormStateArgs = {
data?: Data;
docPermissions: SanitizedDocumentPermissions | undefined;
docPreferences: DocumentPreferences;
/**
* In case `formState` is not the top-level, document form state, this can be passed to
* provide the top-level form state.
*/
documentFormState?: FormState;
fallbackLocale?: false | TypedLocale;
formState?: FormState;
id?: number | string;
initialBlockData?: Data;
initialBlockFormState?: FormState;
language?: keyof SupportedLanguages;
locale?: string;
/**
* If true, will not render RSCs and instead return a simple string in their place.
* This is useful for environments that lack RSC support, such as Jest.
* Form state can still be built, but any server components will be omitted.
* @default false
*/
mockRSCs?: boolean;
operation?: 'create' | 'update';
readOnly?: boolean;
/**
* If true, will render field components within their state object.
* Performance optimization: Setting to `false` ensures that only fields that have changed paths will re-render, e.g. new array rows, etc.
* For example, you only need to render ALL fields on initial render, not on every onChange.
*/
renderAllFields?: boolean;
req: PayloadRequest;
/**
* If true, will return a fresh URL for live preview based on the current form state.
* Note: this will run on every form state event, so if your `livePreview.url` function is long running or expensive,
* ensure it caches itself as needed.
*/
returnLivePreviewURL?: boolean;
returnLockStatus?: boolean;
/**
* If true, will return a fresh URL for preview based on the current form state.
* Note: this will run on every form state event, so if your `preview` function is long running or expensive,
* ensure it caches itself as needed.
*/
returnPreviewURL?: boolean;
schemaPath: string;
select?: SelectType;
/**
* When true, sets `user: true` when calling `getClientConfig`.
* This will retrieve the client config in its entirety, even when unauthenticated.
* For example, the create-first-user view needs the entire config, but there is no user yet.
*
* @experimental This property is experimental and may change in the future. Use at your own risk.
*/
skipClientConfigAuth?: boolean;
skipValidation?: boolean;
updateLastEdited?: boolean;
} & ({
collectionSlug: string;
globalSlug?: string;
} | {
collectionSlug?: string;
globalSlug: string;
});
//# sourceMappingURL=Form.d.ts.map

1
.pnpm-store/v10/files/51/8a4e6a4a88f5df8d81fe8954896b1bc3b447d5ad0a4816aadbb4fd902f2d179bfd30550d337df2ed1e0ef39948e90cfc0db2fc98f2c05ac76c1df204ea4d27 Normal file
View File

File diff suppressed because one or more lines are too long

1
.pnpm-store/v10/files/51/8ec3ff0114a4ec957d9023502b3a3cdce8523a356b1f0284c7b539927a776327adcd322e2f46ec65854e9b6ef02cc29ca22812693cf2a3a3efa49fde5009d5 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../../../src/fields/hooks/afterChange/traverseFields.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../../collections/config/types.js'\nimport type { SanitizedGlobalConfig } from '../../../globals/config/types.js'\nimport type { RequestContext } from '../../../index.js'\nimport type { JsonObject, PayloadRequest } from '../../../types/index.js'\nimport type { Field, TabAsField } from '../../config/types.js'\n\nimport { promise } from './promise.js'\n\ntype Args = {\n /**\n * Data of the nearest parent block. If no parent block exists, this will be the `undefined`\n */\n blockData?: JsonObject\n collection: null | SanitizedCollectionConfig\n context: RequestContext\n data: JsonObject\n doc: JsonObject\n fields: (Field | TabAsField)[]\n global: null | SanitizedGlobalConfig\n operation: 'create' | 'update'\n parentIndexPath: string\n /**\n * @todo make required in v4.0\n */\n parentIsLocalized?: boolean\n parentPath: string\n parentSchemaPath: string\n previousDoc: JsonObject\n previousSiblingDoc: JsonObject\n req: PayloadRequest\n siblingData: JsonObject\n siblingDoc: JsonObject\n siblingFields?: (Field | TabAsField)[]\n}\n\nexport const traverseFields = async ({\n blockData,\n collection,\n context,\n data,\n doc,\n fields,\n global,\n operation,\n parentIndexPath,\n parentIsLocalized,\n parentPath,\n parentSchemaPath,\n previousDoc,\n previousSiblingDoc,\n req,\n siblingData,\n siblingDoc,\n siblingFields,\n}: Args): Promise<void> => {\n const promises: Promise<void>[] = []\n\n fields.forEach((field, fieldIndex) => {\n promises.push(\n promise({\n blockData,\n collection,\n context,\n data,\n doc,\n field,\n fieldIndex,\n global,\n operation,\n parentIndexPath,\n parentIsLocalized: parentIsLocalized!,\n parentPath,\n parentSchemaPath,\n previousDoc,\n previousSiblingDoc,\n req,\n siblingData,\n siblingDoc,\n siblingFields,\n }),\n )\n })\n\n await Promise.all(promises)\n}\n"],"names":["promise","traverseFields","blockData","collection","context","data","doc","fields","global","operation","parentIndexPath","parentIsLocalized","parentPath","parentSchemaPath","previousDoc","previousSiblingDoc","req","siblingData","siblingDoc","siblingFields","promises","forEach","field","fieldIndex","push","Promise","all"],"mappings":"AAMA,SAASA,OAAO,QAAQ,eAAc;AA6BtC,OAAO,MAAMC,iBAAiB,OAAO,EACnCC,SAAS,EACTC,UAAU,EACVC,OAAO,EACPC,IAAI,EACJC,GAAG,EACHC,MAAM,EACNC,MAAM,EACNC,SAAS,EACTC,eAAe,EACfC,iBAAiB,EACjBC,UAAU,EACVC,gBAAgB,EAChBC,WAAW,EACXC,kBAAkB,EAClBC,GAAG,EACHC,WAAW,EACXC,UAAU,EACVC,aAAa,EACR;IACL,MAAMC,WAA4B,EAAE;IAEpCb,OAAOc,OAAO,CAAC,CAACC,OAAOC;QACrBH,SAASI,IAAI,CACXxB,QAAQ;YACNE;YACAC;YACAC;YACAC;YACAC;YACAgB;YACAC;YACAf;YACAC;YACAC;YACAC,mBAAmBA;YACnBC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;YACAC;QACF;IAEJ;IAEA,MAAMM,QAAQC,GAAG,CAACN;AACpB,EAAC"}

30
.pnpm-store/v10/files/51/917ceacc1d146eb83089ca0dba17bfa42b6209ea81308abab3645bda213956768ec5fbfe57d01d3a934f81e37e67e43f70a9e3f5bf53c9bcd39792ad584d84 Normal file
View File

@@ -0,0 +1,30 @@
import { constructNow } from "./constructNow.mjs";
import { isSameMonth } from "./isSameMonth.mjs";
/**
* @name isThisMonth
* @category Month Helpers
* @summary Is the given date in the same month as the current date?
* @pure false
*
* @description
* Is the given date in the same month as the current date?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to check
*
* @returns The date is in this month
*
* @example
* // If today is 25 September 2014, is 15 September 2014 in this month?
* const result = isThisMonth(new Date(2014, 8, 15))
* //=> true
*/
export function isThisMonth(date) {
return isSameMonth(date, constructNow(date));
}
// Fallback for modularized imports:
export default isThisMonth;

2
.pnpm-store/v10/files/51/91bace514655bb659fc1809b020b32a17d02fcd74c9b1969462db219ef641084693a75607050c1b3351c7ada266035a051017a912bef1d2c11b89e359de2e2 Normal file
View File

@@ -0,0 +1,2 @@
import { lowerCase } from "./index";
export = lowerCase;

132
.pnpm-store/v10/files/51/931895f47a73bc54c512429b709103a24743225f2f612c84e5d3dde2b3b50ef64077455a0947b0b5c91055bc0473c1ec765b59bf7f5147f7d84a8f0150beab Normal file
View File

@@ -0,0 +1,132 @@
import { buildMatchFn } from "../../_lib/buildMatchFn.mjs";
import { buildMatchPatternFn } from "../../_lib/buildMatchPatternFn.mjs";
const matchOrdinalNumberPattern = /^(\d+)(d|na|tr|mh)?/i;
const parseOrdinalNumberPattern = /\d+/i;
const matchEraPatterns = {
narrow: /^(r|a)/i,
abbreviated: /^(r\.?\s?c\.?|r\.?\s?a\.?\s?c\.?|a\.?\s?d\.?|a\.?\s?c\.?)/i,
wide: /^(ro Chrìosta|ron aois choitchinn|anno domini|aois choitcheann)/i,
};
const parseEraPatterns = {
any: [/^b/i, /^(a|c)/i],
};
const matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^c[1234]/i,
wide: /^[1234](cd|na|tr|mh)? cairteal/i,
};
const parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i],
};
const matchMonthPatterns = {
narrow: /^[fgmcòilsd]/i,
abbreviated: /^(faoi|gear|màrt|gibl|cèit|ògmh|iuch|lùn|sult|dàmh|samh|dùbh)/i,
wide: /^(am faoilleach|an gearran|am màrt|an giblean|an cèitean|an t-Ògmhios|an t-Iuchar|an lùnastal|an t-Sultain|an dàmhair|an t-Samhain|an dùbhlachd)/i,
};
const parseMonthPatterns = {
narrow: [
/^f/i,
/^g/i,
/^m/i,
/^g/i,
/^c/i,
/^ò/i,
/^i/i,
/^l/i,
/^s/i,
/^d/i,
/^s/i,
/^d/i,
],
any: [
/^fa/i,
/^ge/i,
/^mà/i,
/^gi/i,
/^c/i,
/^ò/i,
/^i/i,
/^l/i,
/^su/i,
/^d/i,
/^sa/i,
/^d/i,
],
};
const matchDayPatterns = {
narrow: /^[dlmcahs]/i,
short: /^(dò|lu|mà|ci|ar|ha|sa)/i,
abbreviated: /^(did|dil|dim|dic|dia|dih|dis)/i,
wide: /^(didòmhnaich|diluain|dimàirt|diciadain|diardaoin|dihaoine|disathairne)/i,
};
const parseDayPatterns = {
narrow: [/^d/i, /^l/i, /^m/i, /^c/i, /^a/i, /^h/i, /^s/i],
any: [/^d/i, /^l/i, /^m/i, /^c/i, /^a/i, /^h/i, /^s/i],
};
const matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(san|aig) (madainn|feasgar|feasgar|oidhche))/i,
any: /^([ap]\.?\s?m\.?|meadhan oidhche|meadhan là|(san|aig) (madainn|feasgar|feasgar|oidhche))/i,
};
const parseDayPeriodPatterns = {
any: {
am: /^m/i,
pm: /^f/i,
midnight: /^meadhan oidhche/i,
noon: /^meadhan là/i,
morning: /sa mhadainn/i,
afternoon: /feasgar/i,
evening: /feasgar/i,
night: /air an oidhche/i,
},
};
export const match = {
ordinalNumber: buildMatchPatternFn({
matchPattern: matchOrdinalNumberPattern,
parsePattern: parseOrdinalNumberPattern,
valueCallback: (value) => parseInt(value, 10),
}),
era: buildMatchFn({
matchPatterns: matchEraPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseEraPatterns,
defaultParseWidth: "any",
}),
quarter: buildMatchFn({
matchPatterns: matchQuarterPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseQuarterPatterns,
defaultParseWidth: "any",
valueCallback: (index) => index + 1,
}),
month: buildMatchFn({
matchPatterns: matchMonthPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseMonthPatterns,
defaultParseWidth: "any",
}),
day: buildMatchFn({
matchPatterns: matchDayPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseDayPatterns,
defaultParseWidth: "any",
}),
dayPeriod: buildMatchFn({
matchPatterns: matchDayPeriodPatterns,
defaultMatchWidth: "any",
parsePatterns: parseDayPeriodPatterns,
defaultParseWidth: "any",
}),
};

1
.pnpm-store/v10/files/51/932cbbbfa3a1c55e4e9adb2c35c8e1aaf3295853be6395718b15c4ad5973911ddf2b46a9bc8e5834c2a2ffd495e8c3502775f54fafce79775cc093d0daa09a Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"lru.d.ts","sourceRoot":"","sources":["../../../src/utils/lru.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC;IAGH,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;gBAEC,QAAQ,EAAE,MAAM;IAIpD,wCAAwC;IACxC,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,yGAAyG;IAClG,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAWjC,wEAAwE;IACjE,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAUlC,kEAAkE;IAC3D,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAQpC,wBAAwB;IACjB,KAAK,IAAI,IAAI;IAIpB,uBAAuB;IAChB,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC;IAIvB,yBAAyB;IAClB,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC;CAK1B"}

1
.pnpm-store/v10/files/51/9378d99984eb53961e7112500e3320aa22d0eee8b29c65f3206cd455a0f0087d4b3b93eb1dcb40115a76b04bc2e1f0c37d35eafe616faa7eab6de40d31ef8d Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"fields.cjs","names":[],"sources":["../../../../src/rest/commands/delete/fields.ts"],"sourcesContent":["import type { DirectusField } from '../../../schema/field.js';\nimport type { RestCommand } from '../../types.js';\nimport { throwIfEmpty } from '../../utils/index.js';\n\n/**\n * Deletes the given field in the given collection.\n * @param collection\n * @param field\n * @returns\n * @throws Will throw if collection is empty\n * @throws Will throw if field is empty\n */\nexport const deleteField =\n\t<Schema>(\n\t\tcollection: DirectusField<Schema>['collection'],\n\t\tfield: DirectusField<Schema>['field'],\n\t): RestCommand<void, Schema> =>\n\t() => {\n\t\tthrowIfEmpty(collection, 'Collection cannot be empty');\n\t\tthrowIfEmpty(field, 'Field cannot be empty');\n\n\t\treturn {\n\t\t\tpath: `/fields/${collection}/${field}`,\n\t\t\tmethod: 'DELETE',\n\t\t};\n\t};\n"],"mappings":"kDAYa,GAEX,EACA,SAGA,EAAA,aAAa,EAAY,6BAA6B,CACtD,EAAA,aAAa,EAAO,wBAAwB,CAErC,CACN,KAAM,WAAW,EAAW,GAAG,IAC/B,OAAQ,SACR"}

78
.pnpm-store/v10/files/51/93ac92dc8257ce40f41b5973bbb88339720afb85af64c7ad2116039a298f77876b0cca36be9cbf3e8f0e7ece62900dc80973420f999f35919ad96720a7877f Normal file
View File

@@ -0,0 +1,78 @@
"use strict";
exports.sub = sub;
var _index = require("./subDays.js");
var _index2 = require("./subMonths.js");
var _index3 = require("./constructFrom.js");
/**
* @name sub
* @category Common Helpers
* @summary Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
*
* @description
* Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param duration - The object with years, months, weeks, days, hours, minutes and seconds to be subtracted
*
* | Key | Description |
* |---------|------------------------------------|
* | years | Amount of years to be subtracted |
* | months | Amount of months to be subtracted |
* | weeks | Amount of weeks to be subtracted |
* | days | Amount of days to be subtracted |
* | hours | Amount of hours to be subtracted |
* | minutes | Amount of minutes to be subtracted |
* | seconds | Amount of seconds to be subtracted |
*
* All values default to 0
*
* @returns The new date with the seconds subtracted
*
* @example
* // Subtract the following duration from 15 June 2017 15:29:20
* const result = sub(new Date(2017, 5, 15, 15, 29, 20), {
* years: 2,
* months: 9,
* weeks: 1,
* days: 7,
* hours: 5,
* minutes: 9,
* seconds: 30
* })
* //=> Mon Sep 1 2014 10:19:50
*/
function sub(date, duration) {
const {
years = 0,
months = 0,
weeks = 0,
days = 0,
hours = 0,
minutes = 0,
seconds = 0,
} = duration;
// Subtract years and months
const dateWithoutMonths = (0, _index2.subMonths)(date, months + years * 12);
// Subtract weeks and days
const dateWithoutDays = (0, _index.subDays)(
dateWithoutMonths,
days + weeks * 7,
);
// Subtract hours, minutes and seconds
const minutestoSub = minutes + hours * 60;
const secondstoSub = seconds + minutestoSub * 60;
const mstoSub = secondstoSub * 1000;
const finalDate = (0, _index3.constructFrom)(
date,
dateWithoutDays.getTime() - mstoSub,
);
return finalDate;
}

1
.pnpm-store/v10/files/51/9740d0c617a3c4890ef86d75974c5aa5576d7cd06521d96958ef41a1a459b4564674765a8d45c1f9d5dd74fbb1dda83df9803a589fbe9be72fcd5275f29021 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"sources":["../../src/utilities/validateWhereQuery.ts"],"sourcesContent":["import type { Operator, Where } from '../types/index.js'\n\nimport { validOperatorSet } from '../types/constants.js'\n\n/**\n * Validates that a \"where\" query is in a format in which the \"where builder\" can understand.\n * Even though basic queries are valid, we need to hoist them into the \"and\" / \"or\" format.\n * Use this function alongside `transformWhereQuery` to perform a transformation if the query is not valid.\n * @example\n * Inaccurate: [text][equals]=example%20post\n * Accurate: [or][0][and][0][text][equals]=example%20post\n */\nexport const validateWhereQuery = (whereQuery: Where): whereQuery is Where => {\n if (\n whereQuery?.or &&\n (whereQuery?.or?.length === 0 ||\n (whereQuery?.or?.length > 0 &&\n whereQuery?.or?.[0]?.and &&\n whereQuery?.or?.[0]?.and?.length > 0))\n ) {\n // At this point we know that the whereQuery has 'or' and 'and' fields,\n // now let's check the structure and content of these fields.\n\n const isValid = whereQuery.or.every((orQuery) => {\n if (orQuery.and && Array.isArray(orQuery.and)) {\n return orQuery.and.every((andQuery) => {\n if (typeof andQuery !== 'object') {\n return false\n }\n\n const andKeys = Object.keys(andQuery)\n\n // If there are no keys, it's not a valid WhereField.\n if (andKeys.length === 0) {\n return false\n }\n\n for (const key of andKeys) {\n const operator = Object.keys(andQuery[key]!)[0]\n // Check if the key is a valid Operator.\n if (!operator || !validOperatorSet.has(operator as Operator)) {\n return false\n }\n }\n return true\n })\n }\n return false\n })\n\n return isValid\n }\n\n return false\n}\n"],"names":["validOperatorSet","validateWhereQuery","whereQuery","or","length","and","isValid","every","orQuery","Array","isArray","andQuery","andKeys","Object","keys","key","operator","has"],"mappings":"AAEA,SAASA,gBAAgB,QAAQ,wBAAuB;AAExD;;;;;;;CAOC,GACD,OAAO,MAAMC,qBAAqB,CAACC;IACjC,IACEA,YAAYC,MACXD,CAAAA,YAAYC,IAAIC,WAAW,KACzBF,YAAYC,IAAIC,SAAS,KACxBF,YAAYC,IAAI,CAAC,EAAE,EAAEE,OACrBH,YAAYC,IAAI,CAAC,EAAE,EAAEE,KAAKD,SAAS,CAAC,GACxC;QACA,uEAAuE;QACvE,6DAA6D;QAE7D,MAAME,UAAUJ,WAAWC,EAAE,CAACI,KAAK,CAAC,CAACC;YACnC,IAAIA,QAAQH,GAAG,IAAII,MAAMC,OAAO,CAACF,QAAQH,GAAG,GAAG;gBAC7C,OAAOG,QAAQH,GAAG,CAACE,KAAK,CAAC,CAACI;oBACxB,IAAI,OAAOA,aAAa,UAAU;wBAChC,OAAO;oBACT;oBAEA,MAAMC,UAAUC,OAAOC,IAAI,CAACH;oBAE5B,qDAAqD;oBACrD,IAAIC,QAAQR,MAAM,KAAK,GAAG;wBACxB,OAAO;oBACT;oBAEA,KAAK,MAAMW,OAAOH,QAAS;wBACzB,MAAMI,WAAWH,OAAOC,IAAI,CAACH,QAAQ,CAACI,IAAI,CAAE,CAAC,EAAE;wBAC/C,wCAAwC;wBACxC,IAAI,CAACC,YAAY,CAAChB,iBAAiBiB,GAAG,CAACD,WAAuB;4BAC5D,OAAO;wBACT;oBACF;oBACA,OAAO;gBACT;YACF;YACA,OAAO;QACT;QAEA,OAAOV;IACT;IAEA,OAAO;AACT,EAAC"}

3
.pnpm-store/v10/files/51/985cf28a923e59d51b6eafb64e459fc8e32ff59d2fb2c6376d6954093f4dc7135de833008138dbf047927d511f71b48afc9f692339abc88f3fda177a7f743b Normal file
View File

@@ -0,0 +1,3 @@
export { useDropAnimation, defaultDropAnimationConfiguration as defaultDropAnimation, defaultDropAnimationSideEffects, } from './useDropAnimation';
export type { DropAnimation, DropAnimationFunction, DropAnimationFunctionArguments, KeyframeResolver as DropAnimationKeyframeResolver, DropAnimationSideEffects, } from './useDropAnimation';
export { useKey } from './useKey';

1
.pnpm-store/v10/files/51/98edad2e7761669ec66e7eae22491e3abdb416281d9de4619fd16a269fb18b3542ed20199f8e19a2bb7097ff466729af83b4c8cb32ae7f7fa19cfefb73a3b3 Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"file-badge.js","sources":["../../../src/icons/file-badge.ts"],"sourcesContent":["import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name FileBadge\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTIgMjJoNmEyIDIgMCAwIDAgMi0yVjdsLTUtNUg2YTIgMiAwIDAgMC0yIDJ2MyIgLz4KICA8cGF0aCBkPSJNMTQgMnY0YTIgMiAwIDAgMCAyIDJoNCIgLz4KICA8cGF0aCBkPSJNNSAxN2EzIDMgMCAxIDAgMC02IDMgMyAwIDAgMCAwIDZaIiAvPgogIDxwYXRoIGQ9Ik03IDE2LjUgOCAyMmwtMy0xLTMgMSAxLTUuNSIgLz4KPC9zdmc+Cg==) - https://lucide.dev/icons/file-badge\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 FileBadge = createLucideIcon('FileBadge', [\n ['path', { d: 'M12 22h6a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3', key: '12ixgl' }],\n ['path', { d: 'M14 2v4a2 2 0 0 0 2 2h4', key: 'tnqrlb' }],\n ['path', { d: 'M5 17a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z', key: 'u0c8gj' }],\n ['path', { d: 'M7 16.5 8 22l-3-1-3 1 1-5.5', key: '5gm2nr' }],\n]);\n\nexport default FileBadge;\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,CAAA,CAC9C,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAmD,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,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,CAChF,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA2B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,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,CACxD,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAAsC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,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,CACnE,CAAC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAQ,CAAA,CAAA,CAAA,CAAE,GAAG,CAA+B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,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;AAC9D,CAAC,CAAA,CAAA;;"}

55
.pnpm-store/v10/files/51/9978d7a1ad5802de06902c32277677afed6df9b48ab048af0551f3420ea89ce736789a7054b67baea4b79405f1e98f13e2277060851c10ff324728f8485cd6 Normal file
View File

@@ -0,0 +1,55 @@
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
const core = require('@sentry/core');
/**
* This is a shim for the OpenFeature integration.
* We need this in order to not throw runtime errors when accidentally importing this on the server through a meta framework like Next.js.
*/
const openFeatureIntegrationShim = core.defineIntegration((_options) => {
if (!core.isBrowser()) {
core.consoleSandbox(() => {
// eslint-disable-next-line no-console
console.warn('The openFeatureIntegration() can only be used in the browser.');
});
}
return {
name: 'OpenFeature',
};
});
/**
* This is a shim for the OpenFeature integration hook.
*/
class OpenFeatureIntegrationHookShim {
/**
*
*/
constructor() {
if (!core.isBrowser()) {
core.consoleSandbox(() => {
// eslint-disable-next-line no-console
console.warn('The OpenFeatureIntegrationHook can only be used in the browser.');
});
}
}
/**
*
*/
after() {
// No-op
}
/**
*
*/
error() {
// No-op
}
}
exports.OpenFeatureIntegrationHookShim = OpenFeatureIntegrationHookShim;
exports.openFeatureIntegrationShim = openFeatureIntegrationShim;
//# sourceMappingURL=openFeature.js.map

26
.pnpm-store/v10/files/51/99ce864c9495ebbd80b763e7dd31108440912f88d9c12b92c2f56e6d42e9a906bb6513eff2de4b0d14d4d48530ef23f1d2a6ba786d9de641749bdf5e4e6ae5 Normal file
View File

@@ -0,0 +1,26 @@
/**
* @license lucide-react v0.441.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 DatabaseBackup = createLucideIcon("DatabaseBackup", [
["ellipse", { cx: "12", cy: "5", rx: "9", ry: "3", key: "msslwz" }],
["path", { d: "M3 12a9 3 0 0 0 5 2.69", key: "1ui2ym" }],
["path", { d: "M21 9.3V5", key: "6k6cib" }],
["path", { d: "M3 5v14a9 3 0 0 0 6.47 2.88", key: "i62tjy" }],
["path", { d: "M12 12v4h4", key: "1bxaet" }],
[
"path",
{
d: "M13 20a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L12 16",
key: "1f4ei9"
}
]
]);
export { DatabaseBackup as default };
//# sourceMappingURL=database-backup.js.map

1
.pnpm-store/v10/files/51/9a48edfd2db320701ff5623ba57f56bfde0980f91a8e121e94cd3657ba3ec2a5dd342b6c2b5800935c85f42eccdc125de2226d2997b3f5e5f43de18b4432ee Normal file
View File

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

52
.pnpm-store/v10/files/51/9a849ab59301b0efb7ee0aaba160a91bcd14a3e405bd6b590274fbb4eb825390cfd00221fe0869aa93b929cd7ab043f01f7624fe6d75e7271978c4f031cbf3 Normal file
View File

@@ -0,0 +1,52 @@
import _typeof from "./typeof.js";
import setPrototypeOf from "./setPrototypeOf.js";
import inherits from "./inherits.js";
function _wrapRegExp() {
_wrapRegExp = function _wrapRegExp(e, r) {
return new BabelRegExp(e, void 0, r);
};
var e = RegExp.prototype,
r = new WeakMap();
function BabelRegExp(e, t, p) {
var o = RegExp(e, t);
return r.set(o, p || r.get(e)), setPrototypeOf(o, BabelRegExp.prototype);
}
function buildGroups(e, t) {
var p = r.get(t);
return Object.keys(p).reduce(function (r, t) {
var o = p[t];
if ("number" == typeof o) r[t] = e[o];else {
for (var i = 0; void 0 === e[o[i]] && i + 1 < o.length;) i++;
r[t] = e[o[i]];
}
return r;
}, Object.create(null));
}
return inherits(BabelRegExp, RegExp), BabelRegExp.prototype.exec = function (r) {
var t = e.exec.call(this, r);
if (t) {
t.groups = buildGroups(t, this);
var p = t.indices;
p && (p.groups = buildGroups(p, this));
}
return t;
}, BabelRegExp.prototype[Symbol.replace] = function (t, p) {
if ("string" == typeof p) {
var o = r.get(this);
return e[Symbol.replace].call(this, t, p.replace(/\$<([^>]+)(>|$)/g, function (e, r, t) {
if ("" === t) return e;
var p = o[r];
return Array.isArray(p) ? "$" + p.join("$") : "number" == typeof p ? "$" + p : "";
}));
}
if ("function" == typeof p) {
var i = this;
return e[Symbol.replace].call(this, t, function () {
var e = arguments;
return "object" != _typeof(e[e.length - 1]) && (e = [].slice.call(e)).push(buildGroups(e, i)), p.apply(this, e);
});
}
return e[Symbol.replace].call(this, t, p);
}, _wrapRegExp.apply(this, arguments);
}
export { _wrapRegExp as default };

Some files were not shown because too many files have changed in this diff Show More