@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

package/node_modules/jose/dist/webapi/jwks/local.js

@@ -1,70 +1,59 @@
-import { jwkToKey } from '../lib/jwk_to_key.js';
-import { JWS } from '../lib/jws_algorithms.js';
-import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
-import { isJwkSet } from '../lib/type_checks.js';
-import { snapshotJwk } from '../lib/jwk_metadata.js';
+import { jwkToKey, snapshotJwk } from "../lib/key.js";
+import { JWS } from "../lib/jws_algorithms.js";
+import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys } from "../util/errors.js";
+import { isJwkSet } from "../lib/validate.js";
 function isUsableJWK(jwk, entry, alg, kid) {
-    const { kty, key_ops, ext, kid: jwkKid, alg: jwkAlg, use, crv } = snapshotJwk(jwk);
-    const keyOps = Array.isArray(key_ops) ? [...key_ops] : key_ops;
-    return ((ext === undefined || typeof ext === 'boolean') &&
-        (keyOps === undefined ||
-            (Array.isArray(keyOps) &&
-                keyOps.every((operation, index) => typeof operation === 'string' && keyOps.indexOf(operation) === index) &&
-                keyOps.includes('verify'))) &&
-        entry.kty.includes(kty) &&
-        (kid === undefined || (typeof kid === 'string' && kid === jwkKid)) &&
-        (jwkAlg === undefined ? kty !== 'AKP' : alg === jwkAlg) &&
-        (use === undefined || use === 'sig') &&
-        (!entry.crv || crv === entry.crv));
+  const { kty, key_ops: keyOps, ext, kid: jwkKid, alg: jwkAlg, use, crv } = jwk;
+  return (ext === void 0 || typeof ext == "boolean") && (keyOps === void 0 || Array.isArray(keyOps) && keyOps.every((operation, index) => typeof operation == "string" && keyOps.indexOf(operation) === index) && keyOps.includes("verify")) && entry.kty.includes(kty) && (kid === void 0 || typeof kid == "string" && kid === jwkKid) && (jwkAlg === void 0 ? kty !== "AKP" : alg === jwkAlg) && (use === void 0 || use === "sig") && (!entry.crv || crv === entry.crv);
 }
 async function importWithAlgCache(cache, jwk, entry) {
-    const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
-    const { alg } = entry;
-    if (cached[alg] === undefined) {
-        const key = await jwkToKey(entry, { ...jwk, alg, ext: true });
-        if (key.type !== 'public') {
-            throw new JWKSInvalid('JSON Web Key Set members must be public keys');
-        }
-        cached[alg] = key;
-    }
-    return cached[alg];
+  const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk), { alg } = entry;
+  if (cached[alg] === void 0) {
+    const pending = jwkToKey(entry, jwk, !0).then((key) => {
+      if (key.type !== "public")
+        throw new JWKSInvalid("JSON Web Key Set members must be public keys");
+      return cached[alg] = key, key;
+    }).catch((error) => {
+      throw cached[alg] === pending && delete cached[alg], error;
+    });
+    cached[alg] = pending;
+  }
+  return cached[alg];
 }
-export function createLocalJWKSet(jwks) {
-    let snapshot;
-    try {
-        snapshot = structuredClone(jwks);
+function createLocalJWKSet(jwks) {
+  let snapshot;
+  try {
+    snapshot = structuredClone(jwks);
+  } catch {
+  }
+  if (!isJwkSet(snapshot))
+    throw new JWKSInvalid("JSON Web Key Set malformed");
+  const metadata = snapshot.keys.map((jwk) => {
+    const normalized = snapshotJwk(jwk);
+    return Array.isArray(normalized.key_ops) && (normalized.key_ops = [...normalized.key_ops]), normalized;
+  }), cached = /* @__PURE__ */ new WeakMap();
+  return Object.defineProperty(async (protectedHeader, token) => {
+    const { alg, kid } = { ...protectedHeader, ...token?.header }, entry = typeof alg == "string" ? JWS[alg] : void 0;
+    if (!entry || entry.secret)
+      throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
+    const candidates = snapshot.keys.filter((_, index) => isUsableJWK(metadata[index], entry, alg, kid)), { 0: jwk, length } = candidates;
+    if (!length)
+      throw new JWKSNoMatchingKey();
+    if (length !== 1) {
+      const error = new JWKSMultipleMatchingKeys();
+      throw error[Symbol.asyncIterator] = async function* () {
+        for (const jwk2 of candidates)
+          try {
+            yield await importWithAlgCache(cached, jwk2, entry);
+          } catch {
+          }
+      }, error;
     }
-    catch { }
-    if (!isJwkSet(snapshot)) {
-        throw new JWKSInvalid('JSON Web Key Set malformed');
-    }
-    const cached = new WeakMap();
-    const localJWKSet = async (protectedHeader, token) => {
-        const { alg, kid } = { ...protectedHeader, ...token?.header };
-        const entry = typeof alg === 'string' ? JWS[alg] : undefined;
-        if (!entry || entry.secret) {
-            throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
-        }
-        const candidates = snapshot.keys.filter((jwk) => isUsableJWK(jwk, entry, alg, kid));
-        const { 0: jwk, length } = candidates;
-        if (!length) {
-            throw new JWKSNoMatchingKey();
-        }
-        if (length !== 1) {
-            const error = new JWKSMultipleMatchingKeys();
-            error[Symbol.asyncIterator] = async function* () {
-                for (const jwk of candidates) {
-                    try {
-                        yield await importWithAlgCache(cached, jwk, entry);
-                    }
-                    catch { }
-                }
-            };
-            throw error;
-        }
-        return importWithAlgCache(cached, jwk, entry);
-    };
-    return Object.defineProperty(localJWKSet, 'jwks', {
-        value: () => structuredClone(snapshot),
-    });
+    return importWithAlgCache(cached, jwk, entry);
+  }, "jwks", {
+    value: () => structuredClone(snapshot)
+  });
 }
+export {
+  createLocalJWKSet
+};

package/node_modules/jose/dist/webapi/jwks/remote.js

@@ -1,149 +1,101 @@
-import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from '../util/errors.js';
-import { createLocalJWKSet } from './local.js';
-import { isJwkSet } from '../lib/type_checks.js';
+import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from "../util/errors.js";
+import { createLocalJWKSet } from "./local.js";
+import { isJwkSet } from "../lib/validate.js";
 function isCloudflareWorkers() {
-    return (typeof WebSocketPair !== 'undefined' ||
-        (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') ||
-        (typeof EdgeRuntime !== 'undefined' && EdgeRuntime === 'vercel'));
+  return typeof WebSocketPair < "u" || typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime < "u" && EdgeRuntime === "vercel";
 }
 let USER_AGENT;
-if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
-    const NAME = 'jose';
-    const VERSION = 'v6.2.10';
-    USER_AGENT = `${NAME}/${VERSION}`;
-}
-export const customFetch = Symbol();
+(typeof navigator > "u" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) && (USER_AGENT = "jose/v6.2.12");
+const customFetch = /* @__PURE__ */ Symbol();
 async function fetchJwks(url, headers, signal, fetchImpl = fetch) {
-    const response = await fetchImpl(url, {
-        method: 'GET',
-        signal,
-        redirect: 'manual',
-        headers,
-    }).catch((err) => {
-        if (err.name === 'TimeoutError') {
-            throw new JWKSTimeout();
-        }
-        throw err;
-    });
-    if (response.status !== 200) {
-        throw new JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
-    }
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new JOSEError('Failed to parse the JSON Web Key Set HTTP response as JSON');
-    }
+  const response = await fetchImpl(url, {
+    method: "GET",
+    signal,
+    redirect: "manual",
+    headers
+  }).catch((err) => {
+    throw err.name === "TimeoutError" ? new JWKSTimeout() : err;
+  });
+  if (response.status !== 200)
+    throw new JOSEError("Expected 200 OK from the JSON Web Key Set HTTP response");
+  try {
+    return await response.json();
+  } catch {
+    throw new JOSEError("Failed to parse the JSON Web Key Set HTTP response as JSON");
+  }
 }
-export const jwksCache = Symbol();
+const jwksCache = /* @__PURE__ */ Symbol();
 function isFreshFor(timestamp, duration) {
-    return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
+  return Number.isFinite(timestamp) && Date.now() < timestamp + duration;
 }
 function validateDuration(value, fallback, option) {
-    if (Number.isNaN(value)) {
-        throw new TypeError(`"${option}" option must not be NaN`);
-    }
-    return typeof value === 'number' ? value : fallback;
+  if (Number.isNaN(value))
+    throw new TypeError(`"${option}" option must not be NaN`);
+  return typeof value == "number" ? value : fallback;
 }
-export function createRemoteJWKSet(url, options) {
-    if (!(url instanceof URL)) {
-        throw new TypeError('url must be an instance of URL');
-    }
-    const href = new URL(url.href).href;
-    const opts = options ?? {};
-    const timeoutOption = opts.timeoutDuration;
-    if (typeof timeoutOption === 'number' &&
-        (!Number.isInteger(timeoutOption) || timeoutOption < 0)) {
-        throw new TypeError('"timeoutDuration" option must be a non-negative integer');
+function createRemoteJWKSet(url, options) {
+  if (!(url instanceof URL))
+    throw new TypeError("url must be an instance of URL");
+  const href = new URL(url.href).href, opts = options ?? {}, timeoutOption = opts.timeoutDuration;
+  if (typeof timeoutOption == "number" && (!Number.isInteger(timeoutOption) || timeoutOption < 0))
+    throw new TypeError('"timeoutDuration" option must be a non-negative integer');
+  const timeoutDuration = typeof timeoutOption == "number" ? timeoutOption : 5e3, cooldownDuration = validateDuration(opts.cooldownDuration, 3e4, "cooldownDuration"), cacheMaxAge = validateDuration(opts.cacheMaxAge, 6e5, "cacheMaxAge"), headers = new Headers(opts.headers);
+  USER_AGENT && !headers.has("User-Agent") && headers.set("User-Agent", USER_AGENT), headers.has("accept") || headers.set("accept", "application/json, application/jwk-set+json");
+  const fetchImpl = opts[customFetch], cache = opts[jwksCache];
+  let jwksTimestamp, pendingFetch, reloadSequence = 0, appliedSequence = 0, local;
+  if (cache && typeof cache == "object") {
+    const { uat, jwks } = cache;
+    isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks) && (jwksTimestamp = uat, local = createLocalJWKSet(jwks));
+  }
+  const reload = async () => {
+    if (pendingFetch && isCloudflareWorkers() && (pendingFetch = void 0), !pendingFetch) {
+      const sequence = ++reloadSequence, current = pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl).then((json) => {
+        const next = createLocalJWKSet(json);
+        if (sequence <= appliedSequence)
+          return;
+        local = next;
+        const updatedAt = Date.now();
+        cache && (cache.uat = updatedAt, cache.jwks = json), jwksTimestamp = updatedAt, appliedSequence = sequence;
+      }).finally(() => {
+        pendingFetch === current && (pendingFetch = void 0);
+      });
     }
-    const timeoutDuration = typeof timeoutOption === 'number' ? timeoutOption : 5000;
-    const cooldownDuration = validateDuration(opts.cooldownDuration, 30000, 'cooldownDuration');
-    const cacheMaxAge = validateDuration(opts.cacheMaxAge, 600000, 'cacheMaxAge');
-    const headers = new Headers(opts.headers);
-    if (USER_AGENT && !headers.has('User-Agent')) {
-        headers.set('User-Agent', USER_AGENT);
-    }
-    if (!headers.has('accept')) {
-        headers.set('accept', 'application/json, application/jwk-set+json');
+    await pendingFetch;
+  };
+  return Object.defineProperties(async (protectedHeader, token) => {
+    (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) && await reload();
+    try {
+      return await local(protectedHeader, token);
+    } catch (err) {
+      if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration))
+        return await reload(), local(protectedHeader, token);
+      throw err;
     }
-    const fetchImpl = opts[customFetch];
-    const cache = opts[jwksCache];
-    let jwksTimestamp;
-    let pendingFetch;
-    let reloadSequence = 0;
-    let appliedSequence = 0;
-    let local;
-    if (cache && typeof cache === 'object') {
-        const { uat, jwks } = cache;
-        if (isFreshFor(uat, cacheMaxAge) && isJwkSet(jwks)) {
-            jwksTimestamp = uat;
-            local = createLocalJWKSet(jwks);
-        }
+  }, {
+    coolingDown: {
+      get: () => isFreshFor(jwksTimestamp, cooldownDuration),
+      enumerable: !0
+    },
+    fresh: {
+      get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
+      enumerable: !0
+    },
+    reload: {
+      value: reload,
+      enumerable: !0
+    },
+    reloading: {
+      get: () => !!pendingFetch,
+      enumerable: !0
+    },
+    jwks: {
+      value: () => local?.jwks(),
+      enumerable: !0
     }
-    const reload = async () => {
-        if (pendingFetch && isCloudflareWorkers()) {
-            pendingFetch = undefined;
-        }
-        if (!pendingFetch) {
-            const sequence = ++reloadSequence;
-            const current = (pendingFetch = fetchJwks(href, headers, AbortSignal.timeout(timeoutDuration), fetchImpl)
-                .then((json) => {
-                const next = createLocalJWKSet(json);
-                if (sequence <= appliedSequence) {
-                    return;
-                }
-                local = next;
-                const updatedAt = Date.now();
-                if (cache) {
-                    cache.uat = updatedAt;
-                    cache.jwks = json;
-                }
-                jwksTimestamp = updatedAt;
-                appliedSequence = sequence;
-            })
-                .finally(() => {
-                if (pendingFetch === current) {
-                    pendingFetch = undefined;
-                }
-            }));
-        }
-        await pendingFetch;
-    };
-    const remoteJWKSet = async (protectedHeader, token) => {
-        if (!local || !isFreshFor(jwksTimestamp, cacheMaxAge)) {
-            await reload();
-        }
-        try {
-            return await local(protectedHeader, token);
-        }
-        catch (err) {
-            if (err instanceof JWKSNoMatchingKey && !isFreshFor(jwksTimestamp, cooldownDuration)) {
-                await reload();
-                return local(protectedHeader, token);
-            }
-            throw err;
-        }
-    };
-    return Object.defineProperties(remoteJWKSet, {
-        coolingDown: {
-            get: () => isFreshFor(jwksTimestamp, cooldownDuration),
-            enumerable: true,
-        },
-        fresh: {
-            get: () => isFreshFor(jwksTimestamp, cacheMaxAge),
-            enumerable: true,
-        },
-        reload: {
-            value: reload,
-            enumerable: true,
-        },
-        reloading: {
-            get: () => !!pendingFetch,
-            enumerable: true,
-        },
-        jwks: {
-            value: () => local?.jwks(),
-            enumerable: true,
-        },
-    });
+  });
 }
+export {
+  createRemoteJWKSet,
+  customFetch,
+  jwksCache
+};

package/node_modules/jose/dist/webapi/jws/compact/sign.js

@@ -1,22 +1,20 @@
-import { createCompactSignature } from '../../lib/jws_sign.js';
-import { assertNotSet } from '../../lib/helpers.js';
-export class CompactSign {
-    #payload;
-    #protectedHeader;
-    constructor(payload) {
-        if (!(payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        this.#payload = payload;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    async sign(key, options) {
-        return createCompactSignature(this.#payload, this.#protectedHeader, options?.crit, key, () => {
-            throw new TypeError('use the flattened module for creating JWS with b64: false');
-        });
-    }
+import { createCompactSignature } from "../../lib/jws_sign.js";
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
+class CompactSign {
+  #payload;
+  #protectedHeader;
+  constructor(payload) {
+    assertUint8Array(payload, "payload"), this.#payload = payload;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#protectedHeader, "setProtectedHeader"), this.#protectedHeader = protectedHeader, this;
+  }
+  async sign(key, options) {
+    return createCompactSignature(this.#payload, this.#protectedHeader, options?.crit, key, () => {
+      throw new TypeError("use the flattened module for creating JWS with b64: false");
+    });
+  }
 }
+export {
+  CompactSign
+};

package/node_modules/jose/dist/webapi/jws/compact/verify.js

@@ -1,9 +1,8 @@
-import { prepareVerify, verifyCompact } from '../../lib/jws_verify.js';
-export async function compactVerify(jws, key, options) {
-    const verified = await verifyCompact(jws, prepareVerify(options), key);
-    const result = { payload: verified[0], protectedHeader: verified[1] };
-    if (typeof key === 'function') {
-        return { ...result, key: verified[3] };
-    }
-    return result;
+import { prepareVerify, verifyCompact } from "../../lib/jws_verify.js";
+async function compactVerify(jws, key, options) {
+  const [result] = await verifyCompact(jws, prepareVerify(options), key);
+  return result;
 }
+export {
+  compactVerify
+};

package/node_modules/jose/dist/webapi/jws/flattened/sign.js

@@ -1,32 +1,23 @@
-import { createSignature } from '../../lib/jws_sign.js';
-import { assertNotSet } from '../../lib/helpers.js';
-export class FlattenedSign {
-    #payload;
-    #protectedHeader;
-    #unprotectedHeader;
-    constructor(payload) {
-        if (!(payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        this.#payload = payload;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
-        this.#unprotectedHeader = unprotectedHeader;
-        return this;
-    }
-    async sign(key, options) {
-        const [jws] = await createSignature({
-            payload: this.#payload,
-            protectedHeader: this.#protectedHeader,
-            unprotectedHeader: this.#unprotectedHeader,
-            crit: options?.crit,
-        }, key);
-        return jws;
-    }
+import { createSignature } from "../../lib/jws_sign.js";
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
+class FlattenedSign {
+  #input;
+  constructor(payload) {
+    assertUint8Array(payload, "payload"), this.#input = [payload];
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#input[1], "setProtectedHeader"), this.#input[1] = protectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.#input[2], "setUnprotectedHeader"), this.#input[2] = unprotectedHeader, this;
+  }
+  async sign(key, options) {
+    const input = [...this.#input];
+    input[3] = options?.crit;
+    const [jws] = await createSignature(input, key);
+    return jws;
+  }
 }
+export {
+  FlattenedSign
+};

package/node_modules/jose/dist/webapi/jws/flattened/verify.js

@@ -1,25 +1,12 @@
-import { JWSInvalid } from '../../util/errors.js';
-import { isObject } from '../../lib/type_checks.js';
-import { encodeJsonUnencodedPayload, prepareVerify, snapshotJws, verifySignature, verifyResult, } from '../../lib/jws_verify.js';
-export async function flattenedVerify(jws, key, options) {
-    if (!isObject(jws)) {
-        throw new JWSInvalid('Flattened JWS must be an object');
-    }
-    const snapshot = snapshotJws(jws);
-    if (snapshot.protected === undefined && snapshot.header === undefined) {
-        throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
-    }
-    if (snapshot.protected !== undefined && typeof snapshot.protected !== 'string') {
-        throw new JWSInvalid('JWS Protected Header incorrect type');
-    }
-    if (snapshot.payload === undefined) {
-        throw new JWSInvalid('JWS Payload missing');
-    }
-    if (typeof snapshot.signature !== 'string') {
-        throw new JWSInvalid('JWS Signature missing or incorrect type');
-    }
-    if (snapshot.header !== undefined && !isObject(snapshot.header)) {
-        throw new JWSInvalid('JWS Unprotected Header incorrect type');
-    }
-    return verifyResult(snapshot, await verifySignature(snapshot, prepareVerify(options), key, encodeJsonUnencodedPayload));
+import { JWSInvalid } from "../../util/errors.js";
+import { isObject } from "../../lib/validate.js";
+import { encodeJsonUnencodedPayload, prepareVerify, snapshotJws, verifySignature } from "../../lib/jws_verify.js";
+async function flattenedVerify(jws, key, options) {
+  if (!isObject(jws))
+    throw new JWSInvalid("Flattened JWS must be an object");
+  const snapshot = snapshotJws(jws), [result] = await verifySignature(snapshot, prepareVerify(options), key, encodeJsonUnencodedPayload);
+  return result;
 }
+export {
+  flattenedVerify
+};

package/node_modules/jose/dist/webapi/jws/general/sign.js

@@ -1,76 +1,58 @@
-import { createSignature } from '../../lib/jws_sign.js';
-import { JWSInvalid } from '../../util/errors.js';
-import { assertNotSet } from '../../lib/helpers.js';
+import { createSignature } from "../../lib/jws_sign.js";
+import { JWSInvalid } from "../../util/errors.js";
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
 class IndividualSignature {
-    #parent;
-    state;
-    constructor(sig, key, options) {
-        this.#parent = sig;
-        this.state = [undefined, undefined, key, options?.crit];
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.state[0], 'setProtectedHeader');
-        this.state[0] = protectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.state[1], 'setUnprotectedHeader');
-        this.state[1] = unprotectedHeader;
-        return this;
-    }
-    addSignature(...args) {
-        return this.#parent.addSignature(...args);
-    }
-    sign(...args) {
-        return this.#parent.sign(...args);
-    }
-    done() {
-        return this.#parent;
-    }
+  #parent;
+  state;
+  constructor(sig, key, options) {
+    this.#parent = sig, this.state = [void 0, void 0, key, options?.crit];
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.state[0], "setProtectedHeader"), this.state[0] = protectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.state[1], "setUnprotectedHeader"), this.state[1] = unprotectedHeader, this;
+  }
+  addSignature(...args) {
+    return this.#parent.addSignature(...args);
+  }
+  sign(...args) {
+    return this.#parent.sign(...args);
+  }
+  done() {
+    return this.#parent;
+  }
 }
-export class GeneralSign {
-    #payload;
-    #signatures = [];
-    constructor(payload) {
-        this.#payload = payload;
-    }
-    addSignature(key, options) {
-        const signature = new IndividualSignature(this, key, options);
-        this.#signatures.push(signature);
-        return signature;
-    }
-    async sign() {
-        if (!this.#signatures.length) {
-            throw new JWSInvalid('at least one signature must be added');
-        }
-        if (!(this.#payload instanceof Uint8Array)) {
-            throw new TypeError('payload must be an instance of Uint8Array');
-        }
-        const jws = {
-            signatures: [],
-            payload: '',
-        };
-        const encoded = [];
-        let b64;
-        for (let i = 0; i < this.#signatures.length; i++) {
-            const signature = this.#signatures[i];
-            const [protectedHeader, unprotectedHeader, key, crit] = signature.state;
-            const [{ payload, ...rest }, signatureB64] = await createSignature({
-                payload: this.#payload,
-                protectedHeader,
-                unprotectedHeader,
-                crit,
-                encoded,
-            }, key);
-            if (b64 === undefined) {
-                b64 = signatureB64;
-                jws.payload = payload;
-            }
-            else if (b64 !== signatureB64) {
-                throw new JWSInvalid('inconsistent use of JWS Unencoded Payload (RFC7797)');
-            }
-            jws.signatures.push(rest);
-        }
-        return jws;
-    }
+class GeneralSign {
+  #payload;
+  #signatures = [];
+  constructor(payload) {
+    this.#payload = payload;
+  }
+  addSignature(key, options) {
+    const signature = new IndividualSignature(this, key, options);
+    return this.#signatures.push(signature), signature;
+  }
+  async sign() {
+    if (!this.#signatures.length)
+      throw new JWSInvalid("at least one signature must be added");
+    assertUint8Array(this.#payload, "payload");
+    const jws = {
+      signatures: [],
+      payload: ""
+    }, encoded = [];
+    let b64;
+    for (const signature of this.#signatures) {
+      const [protectedHeader, unprotectedHeader, key, crit] = signature.state, [{ payload, ...rest }, signatureB64] = await createSignature([this.#payload, protectedHeader, unprotectedHeader, crit, encoded], key);
+      if (b64 === void 0)
+        b64 = signatureB64, jws.payload = payload;
+      else if (b64 !== signatureB64)
+        throw new JWSInvalid("inconsistent use of JWS Unencoded Payload (RFC7797)");
+      jws.signatures.push(rest);
+    }
+    return jws;
+  }
 }
+export {
+  GeneralSign
+};