gossamer

// src/gossamer/key_algorithm.ts
import * as $keyAlgorithm from "./key_algorithm.mjs";
function hashName(hash) {
  return typeof hash === "string" ? hash : hash.name;
}
function toKeyAlgorithm(algorithm2) {
  const name = algorithm2.name;
  if ("namedCurve" in algorithm2) {
    return $keyAlgorithm.KeyAlgorithm$Ec(
      name,
      algorithm2.namedCurve
    );
  }
  if ("modulusLength" in algorithm2) {
    const rsa = algorithm2;
    return $keyAlgorithm.KeyAlgorithm$Rsa(
      name,
      rsa.modulusLength,
      new Uint8Array(rsa.publicExponent),
      hashName(rsa.hash)
    );
  }
  if ("hash" in algorithm2) {
    const hmac = algorithm2;
    return $keyAlgorithm.KeyAlgorithm$Hmac(
      name,
      hashName(hmac.hash),
      hmac.length
    );
  }
  return $keyAlgorithm.KeyAlgorithm$Aes(
    name,
    algorithm2.length
  );
}

// src/gossamer/key_type.ts
import * as $keyType from "./key_type.mjs";
function toKeyType(value) {
  switch (value) {
    case "private":
      return $keyType.KeyType$Private();
    case "public":
      return $keyType.KeyType$Public();
    case "secret":
      return $keyType.KeyType$Secret();
  }
}

// src/gossamer/key_usage.ts
import * as $keyUsage from "./key_usage.mjs";

// src/utils/list.ts
import {
  List$Empty,
  List$isNonEmpty,
  List$NonEmpty,
  List$NonEmpty$first,
  List$NonEmpty$rest
} from "../../prelude.mjs";
function fromArrayMapped(array, map) {
  let list = List$Empty();
  for (let i = array.length - 1; i >= 0; --i) {
    list = List$NonEmpty(map(array[i], i), list);
  }
  return list;
}

// src/gossamer/key_usage.ts
function fromKeyUsage(value) {
  switch (value) {
    case "decrypt":
      return $keyUsage.KeyUsage$Decrypt();
    case "deriveBits":
      return $keyUsage.KeyUsage$DeriveBits();
    case "deriveKey":
      return $keyUsage.KeyUsage$DeriveKey();
    case "encrypt":
      return $keyUsage.KeyUsage$Encrypt();
    case "sign":
      return $keyUsage.KeyUsage$Sign();
    case "unwrapKey":
      return $keyUsage.KeyUsage$UnwrapKey();
    case "verify":
      return $keyUsage.KeyUsage$Verify();
    case "wrapKey":
      return $keyUsage.KeyUsage$WrapKey();
  }
}

// src/gossamer/crypto_key.ffi.ts
var algorithm = (key) => {
  return toKeyAlgorithm(key.algorithm);
};
var is_extractable = (key) => {
  return key.extractable;
};
var type_ = (key) => {
  return toKeyType(key.type);
};
var usages = (key) => {
  return fromArrayMapped(key.usages, fromKeyUsage);
};
export {
  algorithm,
  is_extractable,
  type_,
  usages
};