@psnext/slingcli 3.1.20260904-1 → 3.3.20260914-1

package/node_modules/jose/dist/webapi/lib/base64.js

@@ -1,20 +0,0 @@
-function encodeBase64(input) {
-  if (Uint8Array.prototype.toBase64)
-    return input.toBase64();
-  const CHUNK_SIZE = 32768, arr = [];
-  for (let i = 0; i < input.length; i += CHUNK_SIZE)
-    arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
-  return btoa(arr.join(""));
-}
-function decodeBase64(encoded) {
-  if (Uint8Array.fromBase64)
-    return Uint8Array.fromBase64(encoded);
-  const binary = atob(encoded), bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++)
-    bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-export {
-  decodeBase64,
-  encodeBase64
-};

package/node_modules/jose/dist/webapi/lib/crypto_key.js

@@ -1,27 +0,0 @@
-const unusable = (name, prop = "algorithm.name") => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-function checkUsage(key, usage) {
-  if (usage && !key.usages.includes(usage))
-    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-}
-function checkModulusLength(alg, key) {
-  const { modulusLength } = key.algorithm;
-  if (typeof modulusLength != "number" || modulusLength < 2048)
-    throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-}
-function checkCryptoKey(key, expected, usage) {
-  const algorithm = key.algorithm;
-  if (algorithm.name !== expected.name)
-    throw unusable(expected.name);
-  if (expected.hash && algorithm.hash?.name !== expected.hash)
-    throw unusable(expected.hash, "algorithm.hash");
-  if (expected.namedCurve && algorithm.namedCurve !== expected.namedCurve)
-    throw unusable(expected.namedCurve, "algorithm.namedCurve");
-  if (expected.length !== void 0 && algorithm.length !== expected.length)
-    throw unusable(expected.length, "algorithm.length");
-  checkUsage(key, usage);
-}
-export {
-  checkCryptoKey,
-  checkModulusLength,
-  checkUsage
-};

package/node_modules/jose/dist/webapi/lib/helpers.js

@@ -1,45 +0,0 @@
-import { decode } from "../util/base64url.js";
-import { encode, strictDecoder } from "./buffer_utils.js";
-import { isObject } from "./type_checks.js";
-const unprotected = /* @__PURE__ */ Symbol();
-function assertNotSet(value, name) {
-  if (value !== void 0)
-    throw new TypeError(`${name} can only be called once`);
-}
-function decodeBase64url(value, label, ErrorClass) {
-  try {
-    return decode(value);
-  } catch {
-    throw new ErrorClass(`Failed to base64url decode the ${label}`);
-  }
-}
-function encodeBase64url(value, label, ErrorClass) {
-  try {
-    return encode(value);
-  } catch {
-    throw new ErrorClass(`The ${label} is not a valid base64url string`);
-  }
-}
-async function digest(algorithm, data) {
-  const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-  return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-}
-function parseJoseHeader(b64, ErrorClass, message) {
-  let parsed;
-  try {
-    parsed = JSON.parse(strictDecoder.decode(decode(b64)));
-  } catch {
-    throw new ErrorClass(message);
-  }
-  if (!isObject(parsed))
-    throw new ErrorClass(message);
-  return parsed;
-}
-export {
-  assertNotSet,
-  decodeBase64url,
-  digest,
-  encodeBase64url,
-  parseJoseHeader,
-  unprotected
-};

package/node_modules/jose/dist/webapi/lib/invalid_key_input.js

@@ -1,12 +0,0 @@
-function message(msg, actual, ...types) {
-  if (types.length > 2) {
-    const last = types.pop();
-    msg += `one of type ${types.join(", ")}, or ${last}.`;
-  } else types.length === 2 ? msg += `one of type ${types[0]} or ${types[1]}.` : msg += `of type ${types[0]}.`;
-  return actual == null ? msg += ` Received ${actual}` : typeof actual == "function" && actual.name ? msg += ` Received function ${actual.name}` : typeof actual == "object" && actual != null && actual.constructor?.name && (msg += ` Received an instance of ${actual.constructor.name}`), msg;
-}
-const invalidKeyInput = (actual, ...types) => message("Key must be ", actual, ...types), withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);
-export {
-  invalidKeyInput,
-  withAlg
-};

package/node_modules/jose/dist/webapi/lib/is_key_like.js

@@ -1,19 +0,0 @@
-function assertCryptoKey(key) {
-  if (!isCryptoKey(key))
-    throw new Error("CryptoKey instance expected");
-}
-const isCryptoKey = (key) => {
-  if (key?.[Symbol.toStringTag] === "CryptoKey")
-    return !0;
-  try {
-    return key instanceof CryptoKey;
-  } catch {
-    return !1;
-  }
-}, isKeyObject = (key) => key?.[Symbol.toStringTag] === "KeyObject", isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);
-export {
-  assertCryptoKey,
-  isCryptoKey,
-  isKeyLike,
-  isKeyObject
-};

package/node_modules/jose/dist/webapi/lib/jwk_metadata.js

@@ -1,19 +0,0 @@
-function snapshotJwk(jwk) {
-  return { __proto__: null, ...jwk };
-}
-function normalizeJwk(jwk) {
-  const normalized = snapshotJwk(jwk);
-  if (normalized.ext !== void 0 && typeof normalized.ext != "boolean")
-    throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
-  if (normalized.key_ops !== void 0) {
-    const value = normalized.key_ops, keyOps = Array.isArray(value) ? [...value] : void 0;
-    if (!keyOps || keyOps.some((operation) => typeof operation != "string") || new Set(keyOps).size !== keyOps.length)
-      throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
-    normalized.key_ops = keyOps;
-  }
-  return normalized;
-}
-export {
-  normalizeJwk,
-  snapshotJwk
-};

package/node_modules/jose/dist/webapi/lib/jwk_to_key.js

@@ -1,10 +0,0 @@
-import { JOSENotSupported } from "../util/errors.js";
-async function jwkToKey(entry, jwk) {
-  if (!entry.kty.includes(jwk.kty))
-    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-  const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle, isPrivate = !!(jwk.d || jwk.priv), keyData = { ...jwk };
-  return keyData.kty !== "AKP" && delete keyData.alg, delete keyData.use, crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
-}
-export {
-  jwkToKey
-};

package/node_modules/jose/dist/webapi/lib/key_options.js

@@ -1,8 +0,0 @@
-function validateExtractableOption(extractable) {
-  if (extractable !== void 0 && typeof extractable != "boolean")
-    throw new TypeError('"extractable" option must be a boolean');
-  return extractable;
-}
-export {
-  validateExtractableOption
-};

package/node_modules/jose/dist/webapi/lib/signing.js

@@ -1,22 +0,0 @@
-import { checkCryptoKey, checkModulusLength } from "./crypto_key.js";
-async function getSigKey(entry, key, usage) {
-  return key instanceof Uint8Array ? crypto.subtle.importKey("raw", key, entry.subtle, !1, [
-    usage
-  ]) : (checkCryptoKey(key, entry.subtle, usage), entry.minRsaBits && checkModulusLength(entry.alg, key), key);
-}
-async function sign(entry, key, data) {
-  const cryptoKey = await getSigKey(entry, key, "sign"), signature = await crypto.subtle.sign(entry.signing, cryptoKey, data);
-  return new Uint8Array(signature);
-}
-async function verify(entry, key, signature, data) {
-  const cryptoKey = await getSigKey(entry, key, "verify");
-  try {
-    return await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-  } catch {
-    return !1;
-  }
-}
-export {
-  sign,
-  verify
-};

package/node_modules/jose/dist/webapi/lib/type_checks.js

@@ -1,30 +0,0 @@
-function assertUint8Array(input, label) {
-  if (!(input instanceof Uint8Array))
-    throw new TypeError(`${label} must be an instance of Uint8Array`);
-}
-function isObject(input) {
-  if (typeof input != "object" || input === null || Object.prototype.toString.call(input) !== "[object Object]")
-    return !1;
-  const prototype = Object.getPrototypeOf(input);
-  return prototype === null || Object.getPrototypeOf(prototype) === null;
-}
-function isJwkSet(input) {
-  return isObject(input) && Array.isArray(input.keys) && Array.from(input.keys).every(isObject);
-}
-function isDisjoint(...headers) {
-  const parameters = /* @__PURE__ */ new Set();
-  for (const header of headers)
-    if (header)
-      for (const parameter of Object.keys(header)) {
-        if (parameters.has(parameter))
-          return !1;
-        parameters.add(parameter);
-      }
-  return !0;
-}
-export {
-  assertUint8Array,
-  isDisjoint,
-  isJwkSet,
-  isObject
-};