@comate/zulu 0.0.9 → 0.0.12

package/comate-engine/node_modules/pkce-challenge/dist/index.browser.js

@@ -0,0 +1,72 @@
+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-._~";
+    let result = "";
+    const randomUints = await getRandomValues(size);
+    for (let i = 0; i < size; i++) {
+        // cap the value of the randomIndex to mask.length - 1
+        const randomIndex = randomUints[i] % mask.length;
+        result += mask[randomIndex];
+    }
+    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;
+}

package/comate-engine/node_modules/pkce-challenge/dist/index.node.cjs

@@ -0,0 +1,80 @@
+"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-._~";
+    let result = "";
+    const randomUints = await getRandomValues(size);
+    for (let i = 0; i < size; i++) {
+        // cap the value of the randomIndex to mask.length - 1
+        const randomIndex = randomUints[i] % mask.length;
+        result += mask[randomIndex];
+    }
+    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;
+}

package/comate-engine/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>;

package/comate-engine/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>;

package/comate-engine/node_modules/pkce-challenge/dist/index.node.js

@@ -0,0 +1,75 @@
+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-._~";
+    let result = "";
+    const randomUints = await getRandomValues(size);
+    for (let i = 0; i < size; i++) {
+        // cap the value of the randomIndex to mask.length - 1
+        const randomIndex = randomUints[i] % mask.length;
+        result += mask[randomIndex];
+    }
+    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;
+}

package/comate-engine/node_modules/pkce-challenge/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "pkce-challenge",
+  "version": "5.0.0",
+  "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/"
+  ],
+  "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"
+  }
+}

package/comate-engine/node_modules/web-streams-polyfill/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Mattias Buelens
+Copyright (c) 2016 Diwank Singh Tomer
+
+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.

package/comate-engine/node_modules/web-streams-polyfill/README.md

@@ -0,0 +1,119 @@
+# web-streams-polyfill
+
+Web Streams, based on the WHATWG spec reference implementation.  
+
+[![build status](https://api.travis-ci.com/MattiasBuelens/web-streams-polyfill.svg?branch=master)](https://travis-ci.com/MattiasBuelens/web-streams-polyfill)
+[![npm version](https://img.shields.io/npm/v/web-streams-polyfill.svg)](https://www.npmjs.com/package/web-streams-polyfill)
+[![license](https://img.shields.io/npm/l/web-streams-polyfill.svg)](https://github.com/MattiasBuelens/web-streams-polyfill/blob/master/LICENSE)
+
+## Links
+
+ - [Official spec][spec]
+ - [Reference implementation][ref-impl]
+
+## Usage
+
+This library comes in multiple variants:
+* `web-streams-polyfill`: a [ponyfill] that provides the stream implementations 
+  without replacing any globals, targeting ES2015+ environments.
+  Recommended for use in Node 6+ applications, or in web libraries supporting modern browsers.
+* `web-streams-polyfill/es5`: a ponyfill targeting ES5+ environments.
+  Recommended for use in legacy Node applications, or in web libraries supporting older browsers.
+* `web-streams-polyfill/polyfill`: a polyfill that replaces the native stream implementations,
+  targeting ES2015+ environments.
+  Recommended for use in web apps supporting modern browsers through a `<script>` tag.
+* `web-streams-polyfill/polyfill/es5`: a polyfill targeting ES5+ environments.
+  Recommended for use in web apps supporting older browsers through a `<script>` tag.
+
+Each variant also includes TypeScript type definitions, compatible with the DOM type definitions for streams included in TypeScript.
+These type definitions require TypeScript version 4.7 or higher.
+
+In version 4, the list of variants was reworked to have more modern defaults and to reduce the download size of the package.
+See the [migration guide][migrating] for more information.
+
+Usage as a polyfill:
+```html
+<!-- option 1: hosted by unpkg CDN -->
+<script src="https://unpkg.com/web-streams-polyfill/dist/polyfill.js"></script>
+<!-- option 2: self hosted -->
+<script src="/path/to/web-streams-polyfill/dist/polyfill.js"></script>
+<script>
+var readable = new ReadableStream();
+</script>
+```
+Usage as a Node module:
+```js
+var streams = require("web-streams-polyfill");
+var readable = new streams.ReadableStream();
+```
+Usage as a ponyfill from within a ES2015 module:
+```js
+import { ReadableStream } from "web-streams-polyfill";
+const readable = new ReadableStream();
+```
+Usage as a polyfill from within an ES2015 module:
+```js
+import "web-streams-polyfill/polyfill";
+const readable = new ReadableStream();
+```
+
+## Compatibility
+
+The `polyfill` and `ponyfill` variants work in any ES2015-compatible environment.
+
+The `polyfill/es5` and `ponyfill/es5` variants work in any ES5-compatible environment that has a global `Promise`.
+If you need to support older browsers or Node versions that do not have a native `Promise` implementation
+(check the [support table][promise-support]), you must first include a `Promise` polyfill
+(e.g. [promise-polyfill][promise-polyfill]).
+
+[Async iterable support for `ReadableStream`][rs-asynciterator] is available in all variants, but requires an ES2018-compatible environment or a polyfill for `Symbol.asyncIterator`.
+
+[`WritableStreamDefaultController.signal`][ws-controller-signal] is available in all variants, but requires a global `AbortController` constructor. If necessary, consider using a polyfill such as [abortcontroller-polyfill].
+
+[Reading with a BYOB reader][mdn-byob-read] is available in all variants, but requires `ArrayBuffer.prototype.transfer()` or `structuredClone()` to exist in order to correctly transfer the given view's buffer. If not available, then the buffer won't be transferred during the read.
+
+### Tooling compatibility
+
+This package uses [subpath exports](https://nodejs.org/api/packages.html#subpath-exports) for its variants. As such, you need Node 12 or higher in order to `import` or `require()` such a variant.
+
+When using TypeScript, make sure your [`moduleResolution`](https://www.typescriptlang.org/tsconfig#moduleResolution) is set to `"node16"`, `"nodenext"` or `"bundler"`.
+
+## Compliance
+
+The polyfill implements [version `fa4891a` (3 Dec 2024)][spec-snapshot] of the streams specification.
+
+The polyfill is tested against the same [web platform tests][wpt] that are used by browsers to test their native implementations.
+The polyfill aims to pass all tests, although it allows some exceptions for practical reasons:
+* The default (ES2015) variant passes all of the tests, except for the [test for the prototype of `ReadableStream`'s async iterator][wpt-async-iterator-prototype].
+  Retrieving the correct `%AsyncIteratorPrototype%` requires using an async generator (`async function* () {}`), which is invalid syntax before ES2018.
+  Instead, the polyfill [creates its own version][stub-async-iterator-prototype] which is functionally equivalent to the real prototype.
+* The ES5 variant passes the same tests as the ES2015 variant, except for various tests about specific characteristics of the constructors, properties and methods.
+  These test failures do not affect the run-time behavior of the polyfill.
+  For example:
+  * The `name` property of down-leveled constructors is incorrect.
+  * The `length` property of down-leveled constructors and methods with optional arguments is incorrect.
+  * Not all properties and methods are correctly marked as non-enumerable.
+  * Down-leveled class methods are not correctly marked as non-constructable.
+
+## Contributors
+
+Thanks to these people for their work on [the original polyfill][creatorrr-polyfill]:
+
+ - Diwank Singh Tomer ([creatorrr](https://github.com/creatorrr))
+ - Anders Riutta ([ariutta](https://github.com/ariutta))
+
+[spec]: https://streams.spec.whatwg.org
+[ref-impl]: https://github.com/whatwg/streams
+[ponyfill]: https://github.com/sindresorhus/ponyfill
+[migrating]: https://github.com/MattiasBuelens/web-streams-polyfill/blob/master/MIGRATING.md
+[promise-support]: https://kangax.github.io/compat-table/es6/#test-Promise
+[promise-polyfill]: https://www.npmjs.com/package/promise-polyfill
+[rs-asynciterator]: https://streams.spec.whatwg.org/#rs-asynciterator
+[ws-controller-signal]: https://streams.spec.whatwg.org/#ws-default-controller-signal
+[abortcontroller-polyfill]: https://www.npmjs.com/package/abortcontroller-polyfill
+[mdn-byob-read]: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamBYOBReader/read
+[spec-snapshot]: https://streams.spec.whatwg.org/commit-snapshots/fa4891a35ff05281ff8ed66f8ad447644ea7cec3/
+[wpt]: https://github.com/web-platform-tests/wpt/tree/7ef95a1c3f1c178e455b21569eddb31af7c3691f/streams
+[wpt-async-iterator-prototype]: https://github.com/web-platform-tests/wpt/blob/7ef95a1c3f1c178e455b21569eddb31af7c3691f/streams/readable-streams/async-iterator.any.js#L24
+[stub-async-iterator-prototype]: https://github.com/MattiasBuelens/web-streams-polyfill/blob/v4.0.0/src/lib/readable-stream/async-iterator.ts#L143-L147
+[creatorrr-polyfill]: https://github.com/creatorrr/web-streams-polyfill