@naylence/agent-sdk 0.3.6 → 0.3.8

package/dist/browser/index.js

@@ -11,21 +11,30 @@
     });
     function $constructor(name, initializer, params) {
         function init(inst, def) {
-            var _a;
-            Object.defineProperty(inst, "_zod", {
-                value: inst._zod ?? {},
-                enumerable: false,
-            });
-            (_a = inst._zod).traits ?? (_a.traits = new Set());
+            if (!inst._zod) {
+                Object.defineProperty(inst, "_zod", {
+                    value: {
+                        def,
+                        constr: _,
+                        traits: new Set(),
+                    },
+                    enumerable: false,
+                });
+            }
+            if (inst._zod.traits.has(name)) {
+                return;
+            }
             inst._zod.traits.add(name);
             initializer(inst, def);
             // support prototype modifications
-            for (const k in _.prototype) {
-                if (!(k in inst))
-                    Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+            const proto = _.prototype;
+            const keys = Object.keys(proto);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                if (!(k in inst)) {
+                    inst[k] = proto[k].bind(inst);
+                }
             }
-            inst._zod.constr = _;
-            inst._zod.def = def;
         }
         // doesn't work if Parent has a constructor with arguments
         const Parent = params?.Parent ?? Object;
@@ -160,6 +169,14 @@
     function esc(str) {
         return JSON.stringify(str);
     }
+    function slugify(input) {
+        return input
+            .toLowerCase()
+            .trim()
+            .replace(/[^\w\s-]/g, "")
+            .replace(/[\s_-]+/g, "-")
+            .replace(/^-+|-+$/g, "");
+    }
     const captureStackTrace = ("captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { });
     function isObject$2(data) {
         return typeof data === "object" && data !== null && !Array.isArray(data);
@@ -185,6 +202,8 @@
         const ctor = o.constructor;
         if (ctor === undefined)
             return true;
+        if (typeof ctor !== "function")
+            return true;
         // modified prototype
         const prot = ctor.prototype;
         if (isObject$2(prot) === false)
@@ -648,9 +667,6 @@
     // https://stackoverflow.com/questions/7860392/determine-if-string-is-in-base64-using-javascript
     const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
     const base64url$1 = /^[A-Za-z0-9_-]*$/;
-    // based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
-    // export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-    const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
     // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
     const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
     // const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
@@ -1142,7 +1158,7 @@
     const version = {
         major: 4,
         minor: 1,
-        patch: 12,
+        patch: 13,
     };
 
     const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -1345,7 +1361,7 @@
                             code: "invalid_format",
                             format: "url",
                             note: "Invalid hostname",
-                            pattern: hostname.source,
+                            pattern: def.hostname.source,
                             input: payload.value,
                             inst,
                             continue: !def.abort,
@@ -1435,18 +1451,12 @@
     const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def) => {
         def.pattern ?? (def.pattern = ipv4);
         $ZodStringFormat.init(inst, def);
-        inst._zod.onattach.push((inst) => {
-            const bag = inst._zod.bag;
-            bag.format = `ipv4`;
-        });
+        inst._zod.bag.format = `ipv4`;
     });
     const $ZodIPv6 = /*@__PURE__*/ $constructor("$ZodIPv6", (inst, def) => {
         def.pattern ?? (def.pattern = ipv6);
         $ZodStringFormat.init(inst, def);
-        inst._zod.onattach.push((inst) => {
-            const bag = inst._zod.bag;
-            bag.format = `ipv6`;
-        });
+        inst._zod.bag.format = `ipv6`;
         inst._zod.check = (payload) => {
             try {
                 // @ts-ignore
@@ -1516,9 +1526,7 @@
     const $ZodBase64 = /*@__PURE__*/ $constructor("$ZodBase64", (inst, def) => {
         def.pattern ?? (def.pattern = base64);
         $ZodStringFormat.init(inst, def);
-        inst._zod.onattach.push((inst) => {
-            inst._zod.bag.contentEncoding = "base64";
-        });
+        inst._zod.bag.contentEncoding = "base64";
         inst._zod.check = (payload) => {
             if (isValidBase64(payload.value))
                 return;
@@ -1542,9 +1550,7 @@
     const $ZodBase64URL = /*@__PURE__*/ $constructor("$ZodBase64URL", (inst, def) => {
         def.pattern ?? (def.pattern = base64url$1);
         $ZodStringFormat.init(inst, def);
-        inst._zod.onattach.push((inst) => {
-            inst._zod.bag.contentEncoding = "base64url";
-        });
+        inst._zod.bag.contentEncoding = "base64url";
         inst._zod.check = (payload) => {
             if (isValidBase64URL(payload.value))
                 return;
@@ -1628,9 +1634,9 @@
             return payload;
         };
     });
-    const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumber", (inst, def) => {
+    const $ZodNumberFormat = /*@__PURE__*/ $constructor("$ZodNumberFormat", (inst, def) => {
         $ZodCheckNumberFormat.init(inst, def);
-        $ZodNumber.init(inst, def); // no format checksp
+        $ZodNumber.init(inst, def); // no format checks
     });
     const $ZodBoolean = /*@__PURE__*/ $constructor("$ZodBoolean", (inst, def) => {
         $ZodType.init(inst, def);
@@ -1789,7 +1795,7 @@
         const keySet = def.keySet;
         const _catchall = def.catchall._zod;
         const t = _catchall.def.type;
-        for (const key of Object.keys(input)) {
+        for (const key in input) {
             if (keySet.has(key))
                 continue;
             if (t === "never") {
@@ -2188,11 +2194,13 @@
                 return payload;
             }
             const proms = [];
-            if (def.keyType._zod.values) {
-                const values = def.keyType._zod.values;
+            const values = def.keyType._zod.values;
+            if (values) {
                 payload.value = {};
+                const recordKeys = new Set();
                 for (const key of values) {
                     if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+                        recordKeys.add(typeof key === "number" ? key.toString() : key);
                         const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
                         if (result instanceof Promise) {
                             proms.push(result.then((result) => {
@@ -2212,7 +2220,7 @@
                 }
                 let unrecognized;
                 for (const key in input) {
-                    if (!values.has(key)) {
+                    if (!recordKeys.has(key)) {
                         unrecognized = unrecognized ?? [];
                         unrecognized.push(key);
                     }
@@ -2298,13 +2306,14 @@
         if (def.values.length === 0) {
             throw new Error("Cannot create literal schema with no valid values");
         }
-        inst._zod.values = new Set(def.values);
+        const values = new Set(def.values);
+        inst._zod.values = values;
         inst._zod.pattern = new RegExp(`^(${def.values
         .map((o) => (typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)))
         .join("|")})$`);
         inst._zod.parse = (payload, _ctx) => {
             const input = payload.value;
-            if (inst._zod.values.has(input)) {
+            if (values.has(input)) {
                 return payload;
             }
             payload.issues.push({
@@ -2530,8 +2539,8 @@
         $ZodType.init(inst, def);
         defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
         defineLazy(inst._zod, "values", () => def.innerType._zod.values);
-        defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
-        defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+        defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
+        defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
         inst._zod.parse = (payload, ctx) => {
             if (ctx.direction === "backward") {
                 return def.innerType._zod.run(payload, ctx);
@@ -2579,6 +2588,7 @@
         }
     }
 
+    var _a$1;
     class $ZodRegistry {
         constructor() {
             this._map = new WeakMap();
@@ -2628,7 +2638,8 @@
     function registry() {
         return new $ZodRegistry();
     }
-    const globalRegistry = /*@__PURE__*/ registry();
+    (_a$1 = globalThis).__zod_globalRegistry ?? (_a$1.__zod_globalRegistry = registry());
+    const globalRegistry = globalThis.__zod_globalRegistry;
 
     function _string(Class, params) {
         return new Class({
@@ -3059,6 +3070,10 @@
     function _toUpperCase() {
         return _overwrite((input) => input.toUpperCase());
     }
+    // slugify
+    function _slugify() {
+        return _overwrite((input) => slugify(input));
+    }
     function _array(Class, element, params) {
         return new Class({
             type: "array",
@@ -3190,7 +3205,7 @@
     const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
     const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
     // Codec functions
-    const encode$1 = /* @__PURE__ */ _encode(ZodRealError);
+    const encode$2 = /* @__PURE__ */ _encode(ZodRealError);
     const decode$1 = /* @__PURE__ */ _decode(ZodRealError);
     const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
     const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
@@ -3226,7 +3241,7 @@
         inst.safeParseAsync = async (data, params) => safeParseAsync(inst, data, params);
         inst.spa = inst.safeParseAsync;
         // encoding/decoding
-        inst.encode = (data, params) => encode$1(inst, data, params);
+        inst.encode = (data, params) => encode$2(inst, data, params);
         inst.decode = (data, params) => decode$1(inst, data, params);
         inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
         inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
@@ -3302,6 +3317,7 @@
         inst.normalize = (...args) => inst.check(_normalize(...args));
         inst.toLowerCase = () => inst.check(_toLowerCase());
         inst.toUpperCase = () => inst.check(_toUpperCase());
+        inst.slugify = () => inst.check(_slugify());
     });
     const ZodString = /*@__PURE__*/ $constructor("ZodString", (inst, def) => {
         $ZodString.init(inst, def);
@@ -9312,7 +9328,7 @@
                 data = anchors.get(source);
             }
             /* istanbul ignore if */
-            if (!data || data.res === undefined) {
+            if (data?.res === undefined) {
                 const msg = 'This should not happen: Alias anchor was not resolved?';
                 throw new ReferenceError(msg);
             }
@@ -10324,7 +10340,7 @@
                 ws += `\n${indentComment(cs, ctx.indent)}`;
             }
             if (valueStr === '' && !ctx.inFlow) {
-                if (ws === '\n')
+                if (ws === '\n' && valueComment)
                     ws = '\n\n';
             }
             else {
@@ -10972,7 +10988,7 @@
         const num = typeof value === 'number' ? value : Number(value);
         if (!isFinite(num))
             return isNaN(num) ? '.nan' : num < 0 ? '-.inf' : '.inf';
-        let n = JSON.stringify(value);
+        let n = Object.is(value, -0) ? '-0' : JSON.stringify(value);
         if (!format &&
             minFractionDigits &&
             (!tag || tag === 'tag:yaml.org,2002:float') &&
@@ -12228,7 +12244,7 @@
         if (/[^ ]/.test(lineStr)) {
             let count = 1;
             const end = error.linePos[1];
-            if (end && end.line === line && end.col > col) {
+            if (end?.line === line && end.col > col) {
                 count = Math.max(1, Math.min(end.col - col, 80 - ci));
             }
             const pointer = ' '.repeat(ci) + '^'.repeat(count);
@@ -12563,7 +12579,7 @@
             });
             if (!props.found) {
                 if (props.anchor || props.tag || value) {
-                    if (value && value.type === 'block-seq')
+                    if (value?.type === 'block-seq')
                         onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
                     else
                         onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
@@ -12749,7 +12765,7 @@
                     }
                 }
                 else if (value) {
-                    if ('source' in value && value.source && value.source[0] === ':')
+                    if ('source' in value && value.source?.[0] === ':')
                         onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);
                     else
                         onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
@@ -12793,7 +12809,7 @@
         const expectedEnd = isMap ? '}' : ']';
         const [ce, ...ee] = fc.end;
         let cePos = offset;
-        if (ce && ce.source === expectedEnd)
+        if (ce?.source === expectedEnd)
             cePos = ce.offset + ce.source.length;
         else {
             const name = fcName[0].toUpperCase() + fcName.substring(1);
@@ -12873,7 +12889,7 @@
         let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
         if (!tag) {
             const kt = ctx.schema.knownTags[tagName];
-            if (kt && kt.collection === expType) {
+            if (kt?.collection === expType) {
                 ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
                 tag = kt;
             }
@@ -14804,7 +14820,7 @@
         }
         *step() {
             const top = this.peek(1);
-            if (this.type === 'doc-end' && (!top || top.type !== 'doc-end')) {
+            if (this.type === 'doc-end' && top?.type !== 'doc-end') {
                 while (this.stack.length > 0)
                     yield* this.pop();
                 this.stack.push({
@@ -15336,7 +15352,7 @@
                 do {
                     yield* this.pop();
                     top = this.peek(1);
-                } while (top && top.type === 'flow-collection');
+                } while (top?.type === 'flow-collection');
             }
             else if (fc.end.length === 0) {
                 switch (this.type) {
@@ -15607,6 +15623,7 @@
                 Object.assign(out, g.__ENV__);
             try {
                 // import.meta is only available in ESM builds
+                // prettier-ignore
                 // @ts-ignore
                 const ie = (typeof ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) }) !== 'undefined' && undefined) || undefined;
                 if (ie && typeof ie === 'object')
@@ -15675,12 +15692,12 @@
     // --- END ENV SHIM ---
 
     // This file is auto-generated during build - do not edit manually
-    // Generated from package.json version: 0.3.7
+    // Generated from package.json version: 0.3.9
     /**
      * The package version, injected at build time.
      * @internal
      */
-    const VERSION$1 = '0.3.7';
+    const VERSION$1 = '0.3.9';
 
     /**
      * Fame protocol specific error classes with WebSocket close codes and proper inheritance.
@@ -42811,6 +42828,44 @@
 
     getLogger('naylence.fame.welcome.node_welcome_router');
 
+    /**
+     * Fabric Registry
+     *
+     * Provides a mapping from nodes to their associated fabrics.
+     * This allows agents to retrieve the fabric they were registered on
+     * without relying on the global fabric stack.
+     */
+    /**
+     * WeakMap to store the node-to-fabric mapping.
+     * Using WeakMap ensures that nodes can be garbage collected
+     * when no longer referenced elsewhere.
+     */
+    const nodeToFabric = new WeakMap();
+    /**
+     * @internal
+     * Associates a node with its fabric. This should only be called
+     * by fabric implementations when they create or adopt a node.
+     *
+     * @param node - The node to associate
+     * @param fabric - The fabric that owns the node
+     */
+    function _setFabricForNode(node, fabric) {
+        nodeToFabric.set(node, fabric);
+    }
+    /**
+     * Retrieves the fabric associated with a node.
+     *
+     * This is useful for agents that need to access the fabric they
+     * were registered on, particularly in environments where multiple
+     * fabrics exist (e.g., React with multiple FabricProviders).
+     *
+     * @param node - The node to look up
+     * @returns The fabric associated with the node, or undefined if not found
+     */
+    function getFabricForNode(node) {
+        return nodeToFabric.get(node);
+    }
+
     /**
      * Browser-friendly entry point for Naylence Runtime.
      *
@@ -46018,6 +46073,8 @@
                 this._currentNode = await NodeLikeFactory.createNode(nodeConfig);
                 this._ownsNode = true;
             }
+            // Register this fabric in the registry so agents can look it up
+            _setFabricForNode(this._currentNode, this);
             if (this._ownsNode && !this._nodeStarted) {
                 await this.getRequiredNode().start();
                 this._nodeStarted = true;
@@ -55814,6 +55871,7 @@
             this._subscriptions = new Map();
             this._stateLock = new AsyncLock();
             this._node = null;
+            this._fabric = null;
             this._stateStore = null;
             this._stateCache = null;
             this._name = name ?? camelToSnakeCase(this.constructor.name);
@@ -55853,8 +55911,18 @@
             }
             return this._storageProvider;
         }
+        /**
+         * Returns the fabric this agent is registered with.
+         * This is set during onRegister() and should be used instead of FameFabric.current()
+         * when the agent needs to make calls to other agents.
+         */
+        get fabric() {
+            return this._fabric;
+        }
         async onRegister(node) {
             this._node = node;
+            // Look up the fabric from the registry (set by InProcessFameFabric.start())
+            this._fabric = getFabricForNode(node) ?? null;
         }
         async acquireStateLock() {
             let acquiredResolve;
@@ -56101,7 +56169,8 @@
                         envelopeOptions.corrId = String(rpcRequest.id);
                     }
                     const envelope = createFameEnvelope(envelopeOptions);
-                    await FameFabric.current().send(envelope);
+                    const fabricToUse = this._fabric ?? FameFabric.current();
+                    await fabricToUse.send(envelope);
                 }
             }
             catch (error) {
@@ -56996,6 +57065,17 @@
         writeUInt32BE(buf, value);
         return buf;
     }
+    function encode$1(string) {
+        const bytes = new Uint8Array(string.length);
+        for (let i = 0; i < string.length; i++) {
+            const code = string.charCodeAt(i);
+            if (code > 127) {
+                throw new TypeError('non-ASCII string encountered in encode()');
+            }
+            bytes[i] = code;
+        }
+        return bytes;
+    }
 
     function encodeBase64(input) {
         if (Uint8Array.prototype.toBase64) {
@@ -57030,7 +57110,7 @@
         if (encoded instanceof Uint8Array) {
             encoded = decoder.decode(encoded);
         }
-        encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
+        encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
         try {
             return decodeBase64(encoded);
         }
@@ -57174,7 +57254,7 @@
         JWTInvalid: JWTInvalid
     });
 
-    function bitLength$1(alg) {
+    function bitLength(alg) {
         switch (alg) {
             case 'A128GCM':
             case 'A128GCMKW':
@@ -57191,27 +57271,23 @@
                 throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
         }
     }
-    var generateIv = (alg) => crypto.getRandomValues(new Uint8Array(bitLength$1(alg) >> 3));
+    const generateIv = (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
 
-    var checkIvLength = (enc, iv) => {
-        if (iv.length << 3 !== bitLength$1(enc)) {
+    function checkIvLength(enc, iv) {
+        if (iv.length << 3 !== bitLength(enc)) {
             throw new JWEInvalid('Invalid Initialization Vector length');
         }
-    };
+    }
 
-    var checkCekLength = (cek, expected) => {
+    function checkCekLength(cek, expected) {
         const actual = cek.byteLength << 3;
         if (actual !== expected) {
             throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
         }
-    };
-
-    function unusable(name, prop = 'algorithm.name') {
-        return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-    }
-    function isAlgorithm(algorithm, name) {
-        return algorithm.name === name;
     }
+
+    const unusable = (name, prop = 'algorithm.name') => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+    const isAlgorithm = (algorithm, name) => algorithm.name === name;
     function getHashLength(hash) {
         return parseInt(hash.name.slice(4), 10);
     }
@@ -57379,27 +57455,26 @@
         }
         return msg;
     }
-    var invalidKeyInput = (actual, ...types) => {
-        return message('Key must be ', actual, ...types);
-    };
-    function withAlg(alg, actual, ...types) {
-        return message(`Key for the ${alg} algorithm must be `, actual, ...types);
-    }
+    const invalidKeyInput = (actual, ...types) => message('Key must be ', actual, ...types);
+    const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
 
     function assertCryptoKey(key) {
         if (!isCryptoKey(key)) {
             throw new Error('CryptoKey instance expected');
         }
     }
-    function isCryptoKey(key) {
-        return key?.[Symbol.toStringTag] === 'CryptoKey';
-    }
-    function isKeyObject(key) {
-        return key?.[Symbol.toStringTag] === 'KeyObject';
-    }
-    var isKeyLike = (key) => {
-        return isCryptoKey(key) || isKeyObject(key);
+    const isCryptoKey = (key) => {
+        if (key?.[Symbol.toStringTag] === 'CryptoKey')
+            return true;
+        try {
+            return key instanceof CryptoKey;
+        }
+        catch {
+            return false;
+        }
     };
+    const isKeyObject = (key) => key?.[Symbol.toStringTag] === 'KeyObject';
+    const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
 
     async function timingSafeEqual(a, b) {
         if (!(a instanceof Uint8Array)) {
@@ -57442,7 +57517,7 @@
         }
         let plaintext;
         try {
-            plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv, name: 'AES-CBC' }, encKey, ciphertext));
+            plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
         }
         catch {
         }
@@ -57463,7 +57538,7 @@
         try {
             return new Uint8Array(await crypto.subtle.decrypt({
                 additionalData: aad,
-                iv,
+                iv: iv,
                 name: 'AES-GCM',
                 tagLength: 128,
             }, encKey, concat(ciphertext, tag)));
@@ -57472,7 +57547,7 @@
             throw new JWEDecryptionFailed();
         }
     }
-    var decrypt$1 = async (enc, cek, ciphertext, iv, tag, aad) => {
+    async function decrypt$1(enc, cek, ciphertext, iv, tag, aad) {
         if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
             throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
         }
@@ -57499,9 +57574,9 @@
             default:
                 throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
         }
-    };
+    }
 
-    var isDisjoint = (...headers) => {
+    function isDisjoint(...headers) {
         const sources = headers.filter(Boolean);
         if (sources.length === 0 || sources.length === 1) {
             return true;
@@ -57521,12 +57596,10 @@
             }
         }
         return true;
-    };
-
-    function isObjectLike(value) {
-        return typeof value === 'object' && value !== null;
     }
-    var isObject = (input) => {
+
+    const isObjectLike = (value) => typeof value === 'object' && value !== null;
+    function isObject(input) {
         if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {
             return false;
         }
@@ -57538,7 +57611,7 @@
             proto = Object.getPrototypeOf(proto);
         }
         return Object.getPrototypeOf(input) === proto;
-    };
+    }
 
     function checkKeySize(key, alg) {
         if (key.algorithm.length !== parseInt(alg.slice(1, 4), 10)) {
@@ -57565,10 +57638,10 @@
         return new Uint8Array(await crypto.subtle.exportKey('raw', cryptoKeyCek));
     }
 
-    var digest = async (algorithm, data) => {
+    async function digest(algorithm, data) {
         const subtleDigest = `SHA-${algorithm.slice(-3)}`;
         return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-    };
+    }
 
     function lengthAndInput(input) {
         return concat(uint32be(input.length), input);
@@ -57588,14 +57661,14 @@
         }
         return dk.slice(0, dkLen);
     }
-    async function deriveKey$1(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+    async function deriveKey$1(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(), apv = new Uint8Array()) {
         checkEncCryptoKey(publicKey, 'ECDH');
         checkEncCryptoKey(privateKey, 'ECDH', 'deriveBits');
-        const algorithmID = lengthAndInput(encoder.encode(algorithm));
+        const algorithmID = lengthAndInput(encode$1(algorithm));
         const partyUInfo = lengthAndInput(apu);
         const partyVInfo = lengthAndInput(apv);
         const suppPubInfo = uint32be(keyLength);
-        const suppPrivInfo = new Uint8Array(0);
+        const suppPrivInfo = new Uint8Array();
         const otherInfo = concat(algorithmID, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo);
         const Z = new Uint8Array(await crypto.subtle.deriveBits({
             name: publicKey.algorithm.name,
@@ -57622,12 +57695,14 @@
 
     function getCryptoKey(key, alg) {
         if (key instanceof Uint8Array) {
-            return crypto.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']);
+            return crypto.subtle.importKey('raw', key, 'PBKDF2', false, [
+                'deriveBits',
+            ]);
         }
         checkEncCryptoKey(key, alg, 'deriveBits');
         return key;
     }
-    const concatSalt = (alg, p2sInput) => concat(encoder.encode(alg), new Uint8Array([0]), p2sInput);
+    const concatSalt = (alg, p2sInput) => concat(encode$1(alg), Uint8Array.of(0x00), p2sInput);
     async function deriveKey(p2s, alg, p2c, key) {
         if (!(p2s instanceof Uint8Array) || p2s.length < 8) {
             throw new JWEInvalid('PBES2 Salt Input must be 8 or more octets');
@@ -57653,14 +57728,14 @@
         return unwrap$2(alg.slice(-6), derived, encryptedKey);
     }
 
-    var checkKeyLength = (alg, key) => {
+    function checkKeyLength(alg, key) {
         if (alg.startsWith('RS') || alg.startsWith('PS')) {
             const { modulusLength } = key.algorithm;
             if (typeof modulusLength !== 'number' || modulusLength < 2048) {
                 throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
             }
         }
-    };
+    }
 
     const subtleAlgorithm$1 = (alg) => {
         switch (alg) {
@@ -57684,7 +57759,7 @@
         return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm$1(alg), key, encryptedKey));
     }
 
-    function bitLength(alg) {
+    function cekLength(alg) {
         switch (alg) {
             case 'A128GCM':
                 return 128;
@@ -57701,7 +57776,7 @@
                 throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
         }
     }
-    var generateCek = (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
+    const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));
 
     const formatPEM = (b64, descriptor) => {
         const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
@@ -57725,12 +57800,8 @@
         }
         return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
     };
-    const toSPKI = (key) => {
-        return genericExport('public', 'spki', key);
-    };
-    const toPKCS8 = (key) => {
-        return genericExport('private', 'pkcs8', key);
-    };
+    const toSPKI = (key) => genericExport('public', 'spki', key);
+    const toPKCS8 = (key) => genericExport('private', 'pkcs8', key);
     const bytesEqual = (a, b) => {
         if (a.byteLength !== b.length)
             return false;
@@ -58043,7 +58114,7 @@
         }
         return { algorithm, keyUsages };
     }
-    var importJWK$1 = async (jwk) => {
+    async function jwkToKey(jwk) {
         if (!jwk.alg) {
             throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
         }
@@ -58054,7 +58125,7 @@
         }
         delete keyData.use;
         return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
-    };
+    }
 
     async function importSPKI(spki, alg, options) {
         if (typeof spki !== 'string' || spki.indexOf('-----BEGIN PUBLIC KEY-----') !== 0) {
@@ -58091,7 +58162,7 @@
                 if ('oth' in jwk && jwk.oth !== undefined) {
                     throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
                 }
-                return importJWK$1({ ...jwk, alg, ext });
+                return jwkToKey({ ...jwk, alg, ext });
             case 'AKP': {
                 if (typeof jwk.alg !== 'string' || !jwk.alg) {
                     throw new TypeError('missing "alg" (Algorithm) Parameter value');
@@ -58099,11 +58170,11 @@
                 if (alg !== undefined && alg !== jwk.alg) {
                     throw new TypeError('JWK alg and alg option value mismatch');
                 }
-                return importJWK$1({ ...jwk, ext });
+                return jwkToKey({ ...jwk, ext });
             }
             case 'EC':
             case 'OKP':
-                return importJWK$1({ ...jwk, alg, ext });
+                return jwkToKey({ ...jwk, alg, ext });
             default:
                 throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
         }
@@ -58120,7 +58191,7 @@
             name: 'HMAC',
         }, false, ['sign']);
         const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-            iv,
+            iv: iv,
             name: 'AES-CBC',
         }, encKey, plaintext));
         const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
@@ -58138,7 +58209,7 @@
         }
         const encrypted = new Uint8Array(await crypto.subtle.encrypt({
             additionalData: aad,
-            iv,
+            iv: iv,
             name: 'AES-GCM',
             tagLength: 128,
         }, encKey, plaintext));
@@ -58146,7 +58217,7 @@
         const ciphertext = encrypted.slice(0, -16);
         return { ciphertext, tag, iv };
     }
-    var encrypt = async (enc, plaintext, cek, iv, aad) => {
+    async function encrypt(enc, plaintext, cek, iv, aad) {
         if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
             throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
         }
@@ -58174,11 +58245,11 @@
             default:
                 throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
         }
-    };
+    }
 
     async function wrap(alg, key, cek, iv) {
         const jweAlgorithm = alg.slice(0, 7);
-        const wrapped = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
+        const wrapped = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array());
         return {
             encryptedKey: wrapped.ciphertext,
             iv: encode(wrapped.iv),
@@ -58187,10 +58258,10 @@
     }
     async function unwrap(alg, key, encryptedKey, iv, tag) {
         const jweAlgorithm = alg.slice(0, 7);
-        return decrypt$1(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
+        return decrypt$1(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array());
     }
 
-    var decryptKeyManagement = async (alg, key, encryptedKey, joseHeader, options) => {
+    async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
         switch (alg) {
             case 'dir': {
                 if (encryptedKey !== undefined)
@@ -58232,7 +58303,7 @@
                         throw new JWEInvalid('Failed to base64url decode the apv');
                     }
                 }
-                const sharedSecret = await deriveKey$1(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? bitLength(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
+                const sharedSecret = await deriveKey$1(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
                 if (alg === 'ECDH-ES')
                     return sharedSecret;
                 if (encryptedKey === undefined)
@@ -58305,9 +58376,9 @@
                 throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');
             }
         }
-    };
+    }
 
-    var validateCrit = (Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) => {
+    function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
         if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
             throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
         }
@@ -58338,9 +58409,9 @@
             }
         }
         return new Set(protectedHeader.crit);
-    };
+    }
 
-    var validateAlgorithms = (option, algorithms) => {
+    function validateAlgorithms(option, algorithms) {
         if (algorithms !== undefined &&
             (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
             throw new TypeError(`"${option}" option must be an array of strings`);
@@ -58349,22 +58420,14 @@
             return undefined;
         }
         return new Set(algorithms);
-    };
-
-    function isJWK(key) {
-        return isObject(key) && typeof key.kty === 'string';
-    }
-    function isPrivateJWK(key) {
-        return (key.kty !== 'oct' &&
-            ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string'));
-    }
-    function isPublicJWK(key) {
-        return key.kty !== 'oct' && typeof key.d === 'undefined' && typeof key.priv === 'undefined';
-    }
-    function isSecretJWK(key) {
-        return key.kty === 'oct' && typeof key.k === 'string';
     }
 
+    const isJWK = (key) => isObject(key) && typeof key.kty === 'string';
+    const isPrivateJWK = (key) => key.kty !== 'oct' &&
+        ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string');
+    const isPublicJWK = (key) => key.kty !== 'oct' && key.d === undefined && key.priv === undefined;
+    const isSecretJWK = (key) => key.kty === 'oct' && typeof key.k === 'string';
+
     let cache;
     const handleJWK = async (key, jwk, alg, freeze = false) => {
         cache ||= new WeakMap();
@@ -58372,7 +58435,7 @@
         if (cached?.[alg]) {
             return cached[alg];
         }
-        const cryptoKey = await importJWK$1({ ...jwk, alg });
+        const cryptoKey = await jwkToKey({ ...jwk, alg });
         if (freeze)
             Object.freeze(key);
         if (!cached) {
@@ -58505,7 +58568,7 @@
         }
         return cryptoKey;
     };
-    var normalizeKey = async (key, alg) => {
+    async function normalizeKey(key, alg) {
         if (key instanceof Uint8Array) {
             return key;
         }
@@ -58536,7 +58599,7 @@
             return handleJWK(key, key, alg, true);
         }
         throw new Error('unreachable');
-    };
+    }
 
     const tag = (key) => key?.[Symbol.toStringTag];
     const jwkMatchesOp = (alg, key, usage) => {
@@ -58613,12 +58676,12 @@
                 case 'sign':
                     if (isPrivateJWK(key) && jwkMatchesOp(alg, key, usage))
                         return;
-                    throw new TypeError(`JSON Web Key for this operation be a private JWK`);
+                    throw new TypeError(`JSON Web Key for this operation must be a private JWK`);
                 case 'encrypt':
                 case 'verify':
                     if (isPublicJWK(key) && jwkMatchesOp(alg, key, usage))
                         return;
-                    throw new TypeError(`JSON Web Key for this operation be a public JWK`);
+                    throw new TypeError(`JSON Web Key for this operation must be a public JWK`);
             }
         }
         if (!isKeyLike(key)) {
@@ -58644,19 +58707,19 @@
             }
         }
     };
-    var checkKeyType = (alg, key, usage) => {
-        const symmetric = alg.startsWith('HS') ||
-            alg === 'dir' ||
-            alg.startsWith('PBES2') ||
-            /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(alg) ||
-            /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(alg);
-        if (symmetric) {
-            symmetricTypeCheck(alg, key, usage);
-        }
-        else {
-            asymmetricTypeCheck(alg, key, usage);
+    function checkKeyType(alg, key, usage) {
+        switch (alg.substring(0, 2)) {
+            case 'A1':
+            case 'A2':
+            case 'di':
+            case 'HS':
+            case 'PB':
+                symmetricTypeCheck(alg, key, usage);
+                break;
+            default:
+                asymmetricTypeCheck(alg, key, usage);
         }
-    };
+    }
 
     async function flattenedDecrypt(jwe, key, options) {
         if (!isObject(jwe)) {
@@ -58772,10 +58835,10 @@
                 throw new JWEInvalid('Failed to base64url decode the tag');
             }
         }
-        const protectedHeader = encoder.encode(jwe.protected ?? '');
+        const protectedHeader = jwe.protected !== undefined ? encode$1(jwe.protected) : new Uint8Array();
         let additionalData;
         if (jwe.aad !== undefined) {
-            additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(jwe.aad));
+            additionalData = concat(protectedHeader, encode$1('.'), encode$1(jwe.aad));
         }
         else {
             additionalData = protectedHeader;
@@ -58906,7 +58969,7 @@
         return keyToJWK(key);
     }
 
-    var encryptKeyManagement = async (alg, enc, key, providedCek, providedParameters = {}) => {
+    async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
         let encryptedKey;
         let parameters;
         let cek;
@@ -58932,7 +58995,7 @@
                     ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ['deriveBits'])).privateKey;
                 }
                 const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-                const sharedSecret = await deriveKey$1(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? bitLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
+                const sharedSecret = await deriveKey$1(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
                 parameters = { epk: { x, crv, kty } };
                 if (kty === 'EC')
                     parameters.epk.y = y;
@@ -58986,7 +59049,7 @@
             }
         }
         return { cek, encryptedKey, parameters };
-    };
+    }
 
     class FlattenedEncrypt {
         #plaintext;
@@ -59100,20 +59163,24 @@
                 }
             }
             let additionalData;
-            let protectedHeader;
+            let protectedHeaderS;
+            let protectedHeaderB;
             let aadMember;
             if (this.#protectedHeader) {
-                protectedHeader = encoder.encode(encode(JSON.stringify(this.#protectedHeader)));
+                protectedHeaderS = encode(JSON.stringify(this.#protectedHeader));
+                protectedHeaderB = encode$1(protectedHeaderS);
             }
             else {
-                protectedHeader = encoder.encode('');
+                protectedHeaderS = '';
+                protectedHeaderB = new Uint8Array();
             }
             if (this.#aad) {
                 aadMember = encode(this.#aad);
-                additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(aadMember));
+                const aadMemberBytes = encode$1(aadMember);
+                additionalData = concat(protectedHeaderB, encode$1('.'), aadMemberBytes);
             }
             else {
-                additionalData = protectedHeader;
+                additionalData = protectedHeaderB;
             }
             const { ciphertext, tag, iv } = await encrypt(enc, this.#plaintext, cek, this.#iv, additionalData);
             const jwe = {
@@ -59132,7 +59199,7 @@
                 jwe.aad = aadMember;
             }
             if (this.#protectedHeader) {
-                jwe.protected = decoder.decode(protectedHeader);
+                jwe.protected = protectedHeaderS;
             }
             if (this.#sharedUnprotectedHeader) {
                 jwe.unprotected = this.#sharedUnprotectedHeader;
@@ -59147,6 +59214,7 @@
     class IndividualRecipient {
         #parent;
         unprotectedHeader;
+        keyManagementParameters;
         key;
         options;
         constructor(enc, key, options) {
@@ -59161,6 +59229,13 @@
             this.unprotectedHeader = unprotectedHeader;
             return this;
         }
+        setKeyManagementParameters(parameters) {
+            if (this.keyManagementParameters) {
+                throw new TypeError('setKeyManagementParameters can only be called once');
+            }
+            this.keyManagementParameters = parameters;
+            return this;
+        }
         addRecipient(...args) {
             return this.#parent.addRecipient(...args);
         }
@@ -59268,20 +59343,12 @@
             const cek = generateCek(enc);
             const jwe = {
                 ciphertext: '',
-                iv: '',
                 recipients: [],
-                tag: '',
             };
             for (let i = 0; i < this.#recipients.length; i++) {
                 const recipient = this.#recipients[i];
                 const target = {};
                 jwe.recipients.push(target);
-                const joseHeader = {
-                    ...this.#protectedHeader,
-                    ...this.#unprotectedHeader,
-                    ...recipient.unprotectedHeader,
-                };
-                const p2c = joseHeader.alg.startsWith('PBES2') ? 2048 + i : undefined;
                 if (i === 0) {
                     const flattened = await new FlattenedEncrypt(this.#plaintext)
                         .setAdditionalAuthenticatedData(this.#aad)
@@ -59289,7 +59356,7 @@
                         .setProtectedHeader(this.#protectedHeader)
                         .setSharedUnprotectedHeader(this.#unprotectedHeader)
                         .setUnprotectedHeader(recipient.unprotectedHeader)
-                        .setKeyManagementParameters({ p2c })
+                        .setKeyManagementParameters(recipient.keyManagementParameters)
                         .encrypt(recipient.key, {
                         ...recipient.options,
                         [unprotected]: true,
@@ -59313,7 +59380,7 @@
                     this.#unprotectedHeader?.alg;
                 checkKeyType(alg === 'dir' ? enc : alg, recipient.key, 'encrypt');
                 const k = await normalizeKey(recipient.key, alg);
-                const { encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, cek, { p2c });
+                const { encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, cek, recipient.keyManagementParameters);
                 target.encrypted_key = encode(encryptedKey);
                 if (recipient.unprotectedHeader || parameters)
                     target.header = { ...recipient.unprotectedHeader, ...parameters };
@@ -59322,7 +59389,7 @@
         }
     }
 
-    var subtleAlgorithm = (alg, algorithm) => {
+    function subtleAlgorithm(alg, algorithm) {
         const hash = `SHA-${alg.slice(-3)}`;
         switch (alg) {
             case 'HS256':
@@ -59351,9 +59418,9 @@
             default:
                 throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
         }
-    };
+    }
 
-    var getSignKey = async (alg, key, usage) => {
+    async function getSigKey(alg, key, usage) {
         if (key instanceof Uint8Array) {
             if (!alg.startsWith('HS')) {
                 throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
@@ -59362,10 +59429,10 @@
         }
         checkSigCryptoKey(key, alg, usage);
         return key;
-    };
+    }
 
-    var verify = async (alg, key, signature, data) => {
-        const cryptoKey = await getSignKey(alg, key, 'verify');
+    async function verify(alg, key, signature, data) {
+        const cryptoKey = await getSigKey(alg, key, 'verify');
         checkKeyLength(alg, cryptoKey);
         const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
         try {
@@ -59374,7 +59441,7 @@
         catch {
             return false;
         }
-    };
+    }
 
     async function flattenedVerify(jws, key, options) {
         if (!isObject(jws)) {
@@ -59442,7 +59509,11 @@
             resolvedKey = true;
         }
         checkKeyType(alg, key, 'verify');
-        const data = concat(encoder.encode(jws.protected ?? ''), encoder.encode('.'), typeof jws.payload === 'string' ? encoder.encode(jws.payload) : jws.payload);
+        const data = concat(jws.protected !== undefined ? encode$1(jws.protected) : new Uint8Array(), encode$1('.'), typeof jws.payload === 'string'
+            ? b64
+                ? encode$1(jws.payload)
+                : encoder.encode(jws.payload)
+            : jws.payload);
         let signature;
         try {
             signature = decode(jws.signature);
@@ -59524,15 +59595,14 @@
         throw new JWSSignatureVerificationFailed();
     }
 
-    var epoch = (date) => Math.floor(date.getTime() / 1000);
-
+    const epoch = (date) => Math.floor(date.getTime() / 1000);
     const minute = 60;
     const hour = minute * 60;
     const day = hour * 24;
     const week = day * 7;
     const year = day * 365.25;
     const REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-    var secs = (str) => {
+    function secs(str) {
         const matched = REGEX.exec(str);
         if (!matched || (matched[4] && matched[1])) {
             throw new TypeError('Invalid time period format');
@@ -59580,8 +59650,7 @@
             return -numericDate;
         }
         return numericDate;
-    };
-
+    }
     function validateInput(label, input) {
         if (!Number.isFinite(input)) {
             throw new TypeError(`Invalid ${label} input`);
@@ -59747,7 +59816,7 @@
             }
         }
         set iat(value) {
-            if (typeof value === 'undefined') {
+            if (value === undefined) {
                 this.#payload.iat = epoch(new Date());
             }
             else if (value instanceof Date) {
@@ -59823,12 +59892,12 @@
         }
     }
 
-    var sign = async (alg, key, data) => {
-        const cryptoKey = await getSignKey(alg, key, 'sign');
+    async function sign(alg, key, data) {
+        const cryptoKey = await getSigKey(alg, key, 'sign');
         checkKeyLength(alg, cryptoKey);
         const signature = await crypto.subtle.sign(subtleAlgorithm(alg, cryptoKey.algorithm), cryptoKey, data);
         return new Uint8Array(signature);
-    };
+    }
 
     class FlattenedSign {
         #payload;
@@ -59878,32 +59947,38 @@
                 throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
             }
             checkKeyType(alg, key, 'sign');
-            let payload = this.#payload;
+            let payloadS;
+            let payloadB;
             if (b64) {
-                payload = encoder.encode(encode(payload));
+                payloadS = encode(this.#payload);
+                payloadB = encode$1(payloadS);
+            }
+            else {
+                payloadB = this.#payload;
+                payloadS = '';
             }
-            let protectedHeader;
+            let protectedHeaderString;
+            let protectedHeaderBytes;
             if (this.#protectedHeader) {
-                protectedHeader = encoder.encode(encode(JSON.stringify(this.#protectedHeader)));
+                protectedHeaderString = encode(JSON.stringify(this.#protectedHeader));
+                protectedHeaderBytes = encode$1(protectedHeaderString);
             }
             else {
-                protectedHeader = encoder.encode('');
+                protectedHeaderString = '';
+                protectedHeaderBytes = new Uint8Array();
             }
-            const data = concat(protectedHeader, encoder.encode('.'), payload);
+            const data = concat(protectedHeaderBytes, encode$1('.'), payloadB);
             const k = await normalizeKey(key, alg);
             const signature = await sign(alg, k, data);
             const jws = {
                 signature: encode(signature),
-                payload: '',
+                payload: payloadS,
             };
-            if (b64) {
-                jws.payload = decoder.decode(payload);
-            }
             if (this.#unprotectedHeader) {
                 jws.header = this.#unprotectedHeader;
             }
             if (this.#protectedHeader) {
-                jws.protected = decoder.decode(protectedHeader);
+                jws.protected = protectedHeaderString;
             }
             return jws;
         }
@@ -60208,7 +60283,7 @@
             default:
                 throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
         }
-        const data = encoder.encode(JSON.stringify(components));
+        const data = encode$1(JSON.stringify(components));
         return encode(await digest(digestAlgorithm, data));
     }
     async function calculateJwkThumbprintUri(key, digestAlgorithm) {
@@ -60357,7 +60432,7 @@
     let USER_AGENT;
     if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
         const NAME = 'jose';
-        const VERSION = 'v6.1.0';
+        const VERSION = 'v6.1.3';
         USER_AGENT = `${NAME}/${VERSION}`;
     }
     const customFetch = Symbol();
@@ -60663,7 +60738,7 @@
                 algorithm = {
                     name: 'RSA-PSS',
                     hash: `SHA-${alg.slice(-3)}`,
-                    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                    publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                     modulusLength: getModulusLengthOption(options),
                 };
                 keyUsages = ['sign', 'verify'];
@@ -60674,7 +60749,7 @@
                 algorithm = {
                     name: 'RSASSA-PKCS1-v1_5',
                     hash: `SHA-${alg.slice(-3)}`,
-                    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                    publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                     modulusLength: getModulusLengthOption(options),
                 };
                 keyUsages = ['sign', 'verify'];
@@ -60686,7 +60761,7 @@
                 algorithm = {
                     name: 'RSA-OAEP',
                     hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
-                    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                    publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                     modulusLength: getModulusLengthOption(options),
                 };
                 keyUsages = ['decrypt', 'unwrapKey', 'encrypt', 'wrapKey'];