@truto/truto-jsonata 1.0.41 → 1.0.43

package/dist/browser/index.js

@@ -7718,7 +7718,7 @@ var require_select = __commonJS((exports, module) => {
     var regex = rules.inside.source.replace(/</g, start).replace(/>/g, end);
     return new RegExp(regex);
   };
-  var replace = function(regex, name, val) {
+  var replace2 = function(regex, name, val) {
     regex = regex.source;
     regex = regex.replace(name, val.source || val);
     return new RegExp(regex);
@@ -8143,20 +8143,20 @@ var require_select = __commonJS((exports, module) => {
     inside: /(?:"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|<[^"'>]*>|\\["'>]|[^"'>])*/,
     ident: /^(cssid)$/
   };
-  rules.cssid = replace(rules.cssid, "nonascii", rules.nonascii);
-  rules.cssid = replace(rules.cssid, "escape", rules.escape);
-  rules.qname = replace(rules.qname, "cssid", rules.cssid);
-  rules.simple = replace(rules.simple, "cssid", rules.cssid);
-  rules.ref = replace(rules.ref, "cssid", rules.cssid);
-  rules.attr = replace(rules.attr, "cssid", rules.cssid);
-  rules.pseudo = replace(rules.pseudo, "cssid", rules.cssid);
-  rules.inside = replace(rules.inside, `[^"'>]*`, rules.inside);
-  rules.attr = replace(rules.attr, "inside", makeInside("\\[", "\\]"));
-  rules.pseudo = replace(rules.pseudo, "inside", makeInside("\\(", "\\)"));
-  rules.simple = replace(rules.simple, "pseudo", rules.pseudo);
-  rules.simple = replace(rules.simple, "attr", rules.attr);
-  rules.ident = replace(rules.ident, "cssid", rules.cssid);
-  rules.str_escape = replace(rules.str_escape, "escape", rules.escape);
+  rules.cssid = replace2(rules.cssid, "nonascii", rules.nonascii);
+  rules.cssid = replace2(rules.cssid, "escape", rules.escape);
+  rules.qname = replace2(rules.qname, "cssid", rules.cssid);
+  rules.simple = replace2(rules.simple, "cssid", rules.cssid);
+  rules.ref = replace2(rules.ref, "cssid", rules.cssid);
+  rules.attr = replace2(rules.attr, "cssid", rules.cssid);
+  rules.pseudo = replace2(rules.pseudo, "cssid", rules.cssid);
+  rules.inside = replace2(rules.inside, `[^"'>]*`, rules.inside);
+  rules.attr = replace2(rules.attr, "inside", makeInside("\\[", "\\]"));
+  rules.pseudo = replace2(rules.pseudo, "inside", makeInside("\\(", "\\)"));
+  rules.simple = replace2(rules.simple, "pseudo", rules.pseudo);
+  rules.simple = replace2(rules.simple, "attr", rules.attr);
+  rules.ident = replace2(rules.ident, "cssid", rules.cssid);
+  rules.str_escape = replace2(rules.str_escape, "escape", rules.escape);
   var compile = function(sel_) {
     var sel = sel_.replace(/^\s+|\s+$/g, ""), test, filter2 = [], buff = [], subject, qname, cap, op, ref;
     while (sel) {
@@ -23000,7 +23000,7 @@ var init_buffer = __esm(() => {
       return 1;
     return 0;
   };
-  Buffer4.prototype.includes = function includes(val, byteOffset, encoding) {
+  Buffer4.prototype.includes = function includes2(val, byteOffset, encoding) {
     return this.indexOf(val, byteOffset, encoding) !== -1;
   };
   Buffer4.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
@@ -31655,7 +31655,7 @@ var require_side_channel = __commonJS((exports, module) => {
 
 // node_modules/qs/lib/formats.js
 var require_formats = __commonJS((exports, module) => {
-  var replace = String.prototype.replace;
+  var replace2 = String.prototype.replace;
   var percentTwenties = /%20/g;
   var Format = {
     RFC1738: "RFC1738",
@@ -31665,7 +31665,7 @@ var require_formats = __commonJS((exports, module) => {
     default: Format.RFC3986,
     formatters: {
       RFC1738: function(value) {
-        return replace.call(value, percentTwenties, "+");
+        return replace2.call(value, percentTwenties, "+");
       },
       RFC3986: function(value) {
         return String(value);
@@ -37503,6 +37503,18 @@ function values(object) {
 }
 var values_default = values;
 
+// node_modules/lodash-es/includes.js
+var nativeMax4 = Math.max;
+function includes(collection, value, fromIndex, guard) {
+  collection = isArrayLike_default(collection) ? collection : values_default(collection);
+  fromIndex = fromIndex && !guard ? toInteger_default(fromIndex) : 0;
+  var length = collection.length;
+  if (fromIndex < 0) {
+    fromIndex = nativeMax4(length + fromIndex, 0);
+  }
+  return isString_default(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && _baseIndexOf_default(collection, value, fromIndex) > -1;
+}
+var includes_default = includes;
 // node_modules/lodash-es/_parent.js
 function parent(object, path) {
   return path.length < 2 ? object : _baseGet_default(object, _baseSlice_default(path, 0, -1));
@@ -37816,6 +37828,12 @@ function repeat(string, n, guard) {
   return _baseRepeat_default(toString_default(string), n);
 }
 var repeat_default = repeat;
+// node_modules/lodash-es/replace.js
+function replace() {
+  var args = arguments, string = toString_default(args[0]);
+  return args.length < 3 ? string : string.replace(args[1], args[2]);
+}
+var replace_default = replace;
 // node_modules/lodash-es/set.js
 function set(object, path, value) {
   return object == null ? object : _baseSet_default(object, path, value);
@@ -55217,17 +55235,17 @@ function stringify(obj, replacer, spacer, options3) {
     return res;
   }
 }
-function setReplace(replace, val, k, parent2) {
+function setReplace(replace2, val, k, parent2) {
   var propertyDescriptor = Object.getOwnPropertyDescriptor(parent2, k);
   if (propertyDescriptor.get !== undefined) {
     if (propertyDescriptor.configurable) {
-      Object.defineProperty(parent2, k, { value: replace });
+      Object.defineProperty(parent2, k, { value: replace2 });
       arr.push([parent2, k, val, propertyDescriptor]);
     } else {
-      replacerStack.push([val, k, replace]);
+      replacerStack.push([val, k, replace2]);
     }
   } else {
-    parent2[k] = replace;
+    parent2[k] = replace2;
     arr.push([parent2, k, val]);
   }
 }
@@ -67429,6 +67447,160 @@ var check_key_length_default = (alg, key) => {
   }
 };
 
+// node_modules/jose/dist/webapi/lib/asn1.js
+var bytesEqual = (a, b) => {
+  if (a.byteLength !== b.length)
+    return false;
+  for (let i3 = 0;i3 < a.byteLength; i3++) {
+    if (a[i3] !== b[i3])
+      return false;
+  }
+  return true;
+};
+var createASN1State = (data) => ({ data, pos: 0 });
+var parseLength = (state) => {
+  const first = state.data[state.pos++];
+  if (first & 128) {
+    const lengthOfLen = first & 127;
+    let length = 0;
+    for (let i3 = 0;i3 < lengthOfLen; i3++) {
+      length = length << 8 | state.data[state.pos++];
+    }
+    return length;
+  }
+  return first;
+};
+var expectTag = (state, expectedTag, errorMessage) => {
+  if (state.data[state.pos++] !== expectedTag) {
+    throw new Error(errorMessage);
+  }
+};
+var getSubarray = (state, length) => {
+  const result = state.data.subarray(state.pos, state.pos + length);
+  state.pos += length;
+  return result;
+};
+var parseAlgorithmOID = (state) => {
+  expectTag(state, 6, "Expected algorithm OID");
+  const oidLen = parseLength(state);
+  return getSubarray(state, oidLen);
+};
+function parsePKCS8Header(state) {
+  expectTag(state, 48, "Invalid PKCS#8 structure");
+  parseLength(state);
+  expectTag(state, 2, "Expected version field");
+  const verLen = parseLength(state);
+  state.pos += verLen;
+  expectTag(state, 48, "Expected algorithm identifier");
+  const algIdLen = parseLength(state);
+  const algIdStart = state.pos;
+  return { algIdStart, algIdLength: algIdLen };
+}
+var parseECAlgorithmIdentifier = (state) => {
+  const algOid = parseAlgorithmOID(state);
+  if (bytesEqual(algOid, [43, 101, 110])) {
+    return "X25519";
+  }
+  if (!bytesEqual(algOid, [42, 134, 72, 206, 61, 2, 1])) {
+    throw new Error("Unsupported key algorithm");
+  }
+  expectTag(state, 6, "Expected curve OID");
+  const curveOidLen = parseLength(state);
+  const curveOid = getSubarray(state, curveOidLen);
+  for (const { name, oid } of [
+    { name: "P-256", oid: [42, 134, 72, 206, 61, 3, 1, 7] },
+    { name: "P-384", oid: [43, 129, 4, 0, 34] },
+    { name: "P-521", oid: [43, 129, 4, 0, 35] }
+  ]) {
+    if (bytesEqual(curveOid, oid)) {
+      return name;
+    }
+  }
+  throw new Error("Unsupported named curve");
+};
+var genericImport = async (keyFormat, keyData, alg, options3) => {
+  let algorithm;
+  let keyUsages;
+  const isPublic = keyFormat === "spki";
+  const getSigUsages = () => isPublic ? ["verify"] : ["sign"];
+  const getEncUsages = () => isPublic ? ["encrypt", "wrapKey"] : ["decrypt", "unwrapKey"];
+  switch (alg) {
+    case "PS256":
+    case "PS384":
+    case "PS512":
+      algorithm = { name: "RSA-PSS", hash: `SHA-${alg.slice(-3)}` };
+      keyUsages = getSigUsages();
+      break;
+    case "RS256":
+    case "RS384":
+    case "RS512":
+      algorithm = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${alg.slice(-3)}` };
+      keyUsages = getSigUsages();
+      break;
+    case "RSA-OAEP":
+    case "RSA-OAEP-256":
+    case "RSA-OAEP-384":
+    case "RSA-OAEP-512":
+      algorithm = {
+        name: "RSA-OAEP",
+        hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`
+      };
+      keyUsages = getEncUsages();
+      break;
+    case "ES256":
+    case "ES384":
+    case "ES512": {
+      const curveMap = { ES256: "P-256", ES384: "P-384", ES512: "P-521" };
+      algorithm = { name: "ECDSA", namedCurve: curveMap[alg] };
+      keyUsages = getSigUsages();
+      break;
+    }
+    case "ECDH-ES":
+    case "ECDH-ES+A128KW":
+    case "ECDH-ES+A192KW":
+    case "ECDH-ES+A256KW": {
+      try {
+        const namedCurve = options3.getNamedCurve(keyData);
+        algorithm = namedCurve === "X25519" ? { name: "X25519" } : { name: "ECDH", namedCurve };
+      } catch (cause) {
+        throw new JOSENotSupported("Invalid or unsupported key format");
+      }
+      keyUsages = isPublic ? [] : ["deriveBits"];
+      break;
+    }
+    case "Ed25519":
+    case "EdDSA":
+      algorithm = { name: "Ed25519" };
+      keyUsages = getSigUsages();
+      break;
+    case "ML-DSA-44":
+    case "ML-DSA-65":
+    case "ML-DSA-87":
+      algorithm = { name: alg };
+      keyUsages = getSigUsages();
+      break;
+    default:
+      throw new JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
+  }
+  return crypto.subtle.importKey(keyFormat, keyData, algorithm, options3?.extractable ?? (isPublic ? true : false), keyUsages);
+};
+var processPEMData = (pem, pattern) => {
+  return decodeBase64(pem.replace(pattern, ""));
+};
+var fromPKCS8 = (pem, alg, options3) => {
+  const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g);
+  let opts = options3;
+  if (alg?.startsWith?.("ECDH-ES")) {
+    opts ||= {};
+    opts.getNamedCurve = (keyData2) => {
+      const state = createASN1State(keyData2);
+      parsePKCS8Header(state);
+      return parseECAlgorithmIdentifier(state);
+    };
+  }
+  return genericImport("pkcs8", keyData, alg, opts);
+};
+
 // node_modules/jose/dist/webapi/lib/jwk_to_key.js
 function subtleMapping(jwk) {
   let algorithm;
@@ -67539,6 +67711,14 @@ var jwk_to_key_default = async (jwk) => {
   return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
 };
 
+// node_modules/jose/dist/webapi/key/import.js
+async function importPKCS8(pkcs8, alg, options3) {
+  if (typeof pkcs8 !== "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0) {
+    throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
+  }
+  return fromPKCS8(pkcs8, alg, options3);
+}
+
 // node_modules/jose/dist/webapi/lib/validate_crit.js
 var validate_crit_default = (Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) => {
   if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
@@ -68208,12 +68388,27 @@ function assertObjectPayload(payload) {
     throw new Error("Payload must be a non-null object");
   }
 }
-var signJwt = async (payload, key, signOptions, protectHeaders) => {
+var signJwt = async (payload, key, protectHeaders = {}, signOptions) => {
   assertObjectPayload(payload);
   try {
-    const secret = isString_default(key) ? new TextEncoder().encode(key) : key;
-    const jwtBuilder = new SignJWT(payload).setProtectedHeader({ alg: "HS256", typ: "JWT", ...protectHeaders });
-    return await jwtBuilder.sign(secret, signOptions);
+    let signingKey;
+    const alg = protectHeaders.alg;
+    if (!alg) {
+      throw new Error("Algorithm (alg) must be provided in protectHeaders");
+    }
+    const isAsymmetric = alg.startsWith("RS") || alg.startsWith("ES") || alg.startsWith("PS");
+    if (isAsymmetric) {
+      if (!isString_default(key)) {
+        throw new Error("For asymmetric algorithms, key must be a PEM string");
+      }
+      const pemKey = includes_default(key, "\\n") ? replace_default(key, /\\n/g, `
+`) : key;
+      signingKey = await importPKCS8(pemKey, alg);
+    } else {
+      signingKey = isString_default(key) ? new TextEncoder().encode(key) : key;
+    }
+    const jwtBuilder = new SignJWT(payload).setProtectedHeader({ ...protectHeaders, typ: "JWT" });
+    return await jwtBuilder.sign(signingKey, signOptions);
   } catch (error) {
     throw new Error(`JWT signing failed: ${error?.message || String(error)}`);
   }
@@ -68324,4 +68519,4 @@ export {
   trutoJsonata as default
 };
 
-//# debugId=5835659C2F99AEBC64756E2164756E21
+//# debugId=122A99F8E28462F264756E2164756E21