修改后台权限

node_modules/pkce-challenge/CHANGELOG.md

@@ -0,0 +1,114 @@
+# Changelog
+
+## [5.0.1](https://github.com/crouchcd/pkce-challenge/releases/tag/5.0.1) - 2025-11-22
+
+## What's Changed
+* Use even distribution by @RobinVdBroeck in https://github.com/crouchcd/pkce-challenge/pull/38
+
+## New Contributors
+* @RobinVdBroeck made their first contribution in https://github.com/crouchcd/pkce-challenge/pull/38
+
+**Full Changelog**: https://github.com/crouchcd/pkce-challenge/compare/5.0.0...5.0.1
+
+## [5.0.0](https://github.com/crouchcd/pkce-challenge/releases/tag/5.0.0) - 2025-03-30
+
+## What's Changed
+* fix: add support for commonjs module by @li-yechao in https://github.com/crouchcd/pkce-challenge/pull/32
+
+## New Contributors
+* @li-yechao made their first contribution in https://github.com/crouchcd/pkce-challenge/pull/32
+
+**Full Changelog**: https://github.com/crouchcd/pkce-challenge/compare/4.1.0...5.0.0
+
+## [4.1.0](https://github.com/crouchcd/pkce-challenge/releases/tag/4.1.0) - 2024-01-25
+
+## What's Changed
+* Separate entrypoints for node and browser by @mdarocha in https://github.com/crouchcd/pkce-challenge/pull/25
+
+## New Contributors
+* @mdarocha made their first contribution in https://github.com/crouchcd/pkce-challenge/pull/25
+
+**Full Changelog**: https://github.com/crouchcd/pkce-challenge/compare/4.0.1...4.1.0
+
+## [4.0.1](https://github.com/crouchcd/pkce-challenge/releases/tag/4.0.1) - 2023-05-11
+
+- chore: update README (dc76443a502c25ce98258cea3f25fd78a22cb2a8)
+- chore: specify node engines >= 16.20.0 (5e7fc5edbcd0e19f99fc11a9705e5e708a100be8)
+
+## [4.0.0](https://github.com/crouchcd/pkce-challenge/releases/tag/4.0.0) - 2023-05-11
+
+- BREAKING CHANGE: Use Web Cryptography API (#20), closes #21, #18
+
+### Contributors
+
+- [saschanaz](https://github.com/saschanaz)
+
+## [3.1.0] - 2023-03-29
+
+- chore: Use ES6 imports for crypto-js to reduce bundle size
+
+### Contributors
+
+- [gretchenfitze]
+
+## [3.0.0] - 2022-03-28
+
+- feat!: depend on crypto-js for node/browser compatibility. Using Typescript with Parcel.
+
+```js
+// commonjs
+const pkceChallenge = require("pkce-challenge").default;
+
+// es modules
+import pkceChallenge from "pkce-challenge";
+```
+
+## [2.2.0] - 2021-05-19
+
+### Added
+
+- `generateChallenge` exported from index
+
+### Contributors
+
+- [SeyyedKhandon]
+
+## [2.1.0] - 2019-12-20
+
+### Added
+
+- `verifyChallenge` exported from index
+
+### Changed
+
+- code/comment formatting
+- refactored `random` function
+
+## [2.0.0] - 2019-10-18
+
+### Added
+
+- CHANGELOG
+- typescript definition
+- Cryptographically secured method for generating code verifier
+- Method for base64 url encoding
+
+### Removed
+
+- `generateVerifier` export from index
+- `generateChallenge` export from index
+- `base64url` npm dependency
+- `randomatic` npm dependency
+
+### Contributors
+
+- [lordnox]
+
+[gretchenfitze]: https://github.com/gretchenfitze
+[seyyedkhandon]: https://github.com/SeyyedKhandon
+[lordnox]: https://github.com/lordnox
+[3.1.0]: https://github.com/crouchcd/pkce-challenge/releases/tag/3.1.0
+[3.0.0]: https://github.com/crouchcd/pkce-challenge/releases/tag/3.0.0
+[2.2.0]: https://github.com/crouchcd/pkce-challenge/releases/tag/2.2.0
+[2.1.0]: https://github.com/crouchcd/pkce-challenge/releases/tag/2.1.0
+[2.0.0]: https://github.com/crouchcd/pkce-challenge/releases/tag/2.0.0

node_modules/pkce-challenge/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 
+
+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.

node_modules/pkce-challenge/README.md

@@ -0,0 +1,55 @@
+# pkce-challenge
+
+Generate or verify a Proof Key for Code Exchange (PKCE) challenge pair.
+
+Read more about [PKCE](https://www.oauth.com/oauth2-servers/pkce/authorization-request/).
+
+## Installation
+
+```bash
+npm install pkce-challenge
+```
+
+## Usage
+
+Default length for the verifier is 43
+
+```js
+import pkceChallenge from "pkce-challenge";
+
+await pkceChallenge();
+```
+
+gives something like:
+
+```js
+{
+    code_verifier: 'u1ta-MQ0e7TcpHjgz33M2DcBnOQu~aMGxuiZt0QMD1C',
+    code_challenge: 'CUZX5qE8Wvye6kS_SasIsa8MMxacJftmWdsIA_iKp3I'
+}
+```
+
+### Specify a verifier length
+
+```js
+const challenge = await pkceChallenge(128);
+
+challenge.code_verifier.length === 128; // true
+```
+
+### Challenge verification
+
+```js
+import { verifyChallenge } from "pkce-challenge";
+
+(await verifyChallenge(challenge.code_verifier, challenge.code_challenge)) ===
+  true; // true
+```
+
+### Challenge generation from existing code verifier
+
+```js
+import { generateChallenge } from "pkce-challenge";
+
+(await generateChallenge(challenge.code_verifier)) === challenge.code_challenge; // true
+```

node_modules/pkce-challenge/dist/index.browser.d.ts

@@ -0,0 +1,19 @@
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+export declare function generateChallenge(code_verifier: string): Promise<string>;
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+export default function pkceChallenge(length?: number): Promise<{
+    code_verifier: string;
+    code_challenge: string;
+}>;
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+export declare function verifyChallenge(code_verifier: string, expectedChallenge: string): Promise<boolean>;

node_modules/pkce-challenge/dist/index.browser.js

@@ -0,0 +1,75 @@
+let crypto;
+crypto = globalThis.crypto; // web browsers
+/**
+ * Creates an array of length `size` of random bytes
+ * @param size
+ * @returns Array of random ints (0 to 255)
+ */
+async function getRandomValues(size) {
+    return (await crypto).getRandomValues(new Uint8Array(size));
+}
+/** Generate cryptographically strong random string
+ * @param size The desired length of the string
+ * @returns The random string
+ */
+async function random(size) {
+    const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+    const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+    let result = "";
+    while (result.length < size) {
+        const randomBytes = await getRandomValues(size - result.length);
+        for (const randomByte of randomBytes) {
+            if (randomByte < evenDistCutoff) {
+                result += mask[randomByte % mask.length];
+            }
+        }
+    }
+    return result;
+}
+/** Generate a PKCE challenge verifier
+ * @param length Length of the verifier
+ * @returns A random verifier `length` characters long
+ */
+async function generateVerifier(length) {
+    return await random(length);
+}
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+export async function generateChallenge(code_verifier) {
+    const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+    // Generate base64url string
+    // btoa is deprecated in Node.js but is used here for web browser compatibility
+    // (which has no good replacement yet, see also https://github.com/whatwg/html/issues/6811)
+    return btoa(String.fromCharCode(...new Uint8Array(buffer)))
+        .replace(/\//g, '_')
+        .replace(/\+/g, '-')
+        .replace(/=/g, '');
+}
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+export default async function pkceChallenge(length) {
+    if (!length)
+        length = 43;
+    if (length < 43 || length > 128) {
+        throw `Expected a length between 43 and 128. Received ${length}.`;
+    }
+    const verifier = await generateVerifier(length);
+    const challenge = await generateChallenge(verifier);
+    return {
+        code_verifier: verifier,
+        code_challenge: challenge,
+    };
+}
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+export async function verifyChallenge(code_verifier, expectedChallenge) {
+    const actualChallenge = await generateChallenge(code_verifier);
+    return actualChallenge === expectedChallenge;
+}

node_modules/pkce-challenge/dist/index.node.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateChallenge = generateChallenge;
+exports.default = pkceChallenge;
+exports.verifyChallenge = verifyChallenge;
+let crypto;
+crypto =
+    globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+        globalThis.crypto ?? // Node.js >18
+        import("node:crypto").then(m => m.webcrypto); // Node.js <18 Non-REPL
+/**
+ * Creates an array of length `size` of random bytes
+ * @param size
+ * @returns Array of random ints (0 to 255)
+ */
+async function getRandomValues(size) {
+    return (await crypto).getRandomValues(new Uint8Array(size));
+}
+/** Generate cryptographically strong random string
+ * @param size The desired length of the string
+ * @returns The random string
+ */
+async function random(size) {
+    const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+    const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+    let result = "";
+    while (result.length < size) {
+        const randomBytes = await getRandomValues(size - result.length);
+        for (const randomByte of randomBytes) {
+            if (randomByte < evenDistCutoff) {
+                result += mask[randomByte % mask.length];
+            }
+        }
+    }
+    return result;
+}
+/** Generate a PKCE challenge verifier
+ * @param length Length of the verifier
+ * @returns A random verifier `length` characters long
+ */
+async function generateVerifier(length) {
+    return await random(length);
+}
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+async function generateChallenge(code_verifier) {
+    const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+    // Generate base64url string
+    // btoa is deprecated in Node.js but is used here for web browser compatibility
+    // (which has no good replacement yet, see also https://github.com/whatwg/html/issues/6811)
+    return btoa(String.fromCharCode(...new Uint8Array(buffer)))
+        .replace(/\//g, '_')
+        .replace(/\+/g, '-')
+        .replace(/=/g, '');
+}
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+async function pkceChallenge(length) {
+    if (!length)
+        length = 43;
+    if (length < 43 || length > 128) {
+        throw `Expected a length between 43 and 128. Received ${length}.`;
+    }
+    const verifier = await generateVerifier(length);
+    const challenge = await generateChallenge(verifier);
+    return {
+        code_verifier: verifier,
+        code_challenge: challenge,
+    };
+}
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+async function verifyChallenge(code_verifier, expectedChallenge) {
+    const actualChallenge = await generateChallenge(code_verifier);
+    return actualChallenge === expectedChallenge;
+}

node_modules/pkce-challenge/dist/index.node.d.cts

@@ -0,0 +1,19 @@
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+export declare function generateChallenge(code_verifier: string): Promise<string>;
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+export default function pkceChallenge(length?: number): Promise<{
+    code_verifier: string;
+    code_challenge: string;
+}>;
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+export declare function verifyChallenge(code_verifier: string, expectedChallenge: string): Promise<boolean>;

node_modules/pkce-challenge/dist/index.node.d.ts

@@ -0,0 +1,19 @@
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+export declare function generateChallenge(code_verifier: string): Promise<string>;
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+export default function pkceChallenge(length?: number): Promise<{
+    code_verifier: string;
+    code_challenge: string;
+}>;
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+export declare function verifyChallenge(code_verifier: string, expectedChallenge: string): Promise<boolean>;

node_modules/pkce-challenge/dist/index.node.js

@@ -0,0 +1,78 @@
+let crypto;
+crypto =
+    globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+        globalThis.crypto ?? // Node.js >18
+        import("node:crypto").then(m => m.webcrypto); // Node.js <18 Non-REPL
+/**
+ * Creates an array of length `size` of random bytes
+ * @param size
+ * @returns Array of random ints (0 to 255)
+ */
+async function getRandomValues(size) {
+    return (await crypto).getRandomValues(new Uint8Array(size));
+}
+/** Generate cryptographically strong random string
+ * @param size The desired length of the string
+ * @returns The random string
+ */
+async function random(size) {
+    const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+    const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+    let result = "";
+    while (result.length < size) {
+        const randomBytes = await getRandomValues(size - result.length);
+        for (const randomByte of randomBytes) {
+            if (randomByte < evenDistCutoff) {
+                result += mask[randomByte % mask.length];
+            }
+        }
+    }
+    return result;
+}
+/** Generate a PKCE challenge verifier
+ * @param length Length of the verifier
+ * @returns A random verifier `length` characters long
+ */
+async function generateVerifier(length) {
+    return await random(length);
+}
+/** Generate a PKCE code challenge from a code verifier
+ * @param code_verifier
+ * @returns The base64 url encoded code challenge
+ */
+export async function generateChallenge(code_verifier) {
+    const buffer = await (await crypto).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+    // Generate base64url string
+    // btoa is deprecated in Node.js but is used here for web browser compatibility
+    // (which has no good replacement yet, see also https://github.com/whatwg/html/issues/6811)
+    return btoa(String.fromCharCode(...new Uint8Array(buffer)))
+        .replace(/\//g, '_')
+        .replace(/\+/g, '-')
+        .replace(/=/g, '');
+}
+/** Generate a PKCE challenge pair
+ * @param length Length of the verifer (between 43-128). Defaults to 43.
+ * @returns PKCE challenge pair
+ */
+export default async function pkceChallenge(length) {
+    if (!length)
+        length = 43;
+    if (length < 43 || length > 128) {
+        throw `Expected a length between 43 and 128. Received ${length}.`;
+    }
+    const verifier = await generateVerifier(length);
+    const challenge = await generateChallenge(verifier);
+    return {
+        code_verifier: verifier,
+        code_challenge: challenge,
+    };
+}
+/** Verify that a code_verifier produces the expected code challenge
+ * @param code_verifier
+ * @param expectedChallenge The code challenge to verify
+ * @returns True if challenges are equal. False otherwise.
+ */
+export async function verifyChallenge(code_verifier, expectedChallenge) {
+    const actualChallenge = await generateChallenge(code_verifier);
+    return actualChallenge === expectedChallenge;
+}

node_modules/pkce-challenge/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "pkce-challenge",
+  "version": "5.0.1",
+  "description": "Generate or verify a Proof Key for Code Exchange (PKCE) challenge pair",
+  "browser": "dist/index.browser.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": {
+        "require": "./dist/index.node.d.cts",
+        "import": "./dist/index.node.d.ts"
+      },
+      "browser": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "node": {
+        "import": "./dist/index.node.js",
+        "require": "./dist/index.node.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist/",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "watch": "tsc --watch --declaration",
+    "preprocess": "env=browser diverge -f src/index.ts src/index.browser.ts && env=node diverge -f src/index.ts src/index.node.ts && env=node diverge -f src/index.ts src/index.node.cts",
+    "build": "npm run preprocess && tsc --declaration",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:bundle": "npm run --prefix browser-test build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crouchcd/pkce-challenge.git"
+  },
+  "keywords": [
+    "PKCE",
+    "oauth2"
+  ],
+  "author": "crouchcd",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/crouchcd/pkce-challenge/issues"
+  },
+  "homepage": "https://github.com/crouchcd/pkce-challenge#readme",
+  "engines": {
+    "node": ">=16.20.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "diverge": "^1.0.2",
+    "esbuild": "^0.25.2",
+    "jest": "^29.5.0",
+    "typescript": "^5.0.3"
+  }
+}