volter 0.0.173 → 0.0.174

package/LICENSE

@@ -0,0 +1,27 @@
+The Modlin Distributable License (MDL)
+
+Copyright (c) 2025 Modlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+Any use, distribution, modification, integration, or implementation of the
+Software in another project must include clear and visible credit to the
+Software and to its original author. This credit must be placed in all public
+distributions, documentation, and any “About” or “Credits” section of the
+implementing project.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/crypto.js

@@ -1,141 +1,2 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/crypto.ts
-function hash(password, hmac) {
-  const hasher = new Bun.CryptoHasher("sha256", hmac);
-  return hasher.update(password).digest("hex");
-}
-async function cryptoKey(raw) {
-  if (raw) {
-    if (raw instanceof CryptoKey)
-      return raw;
-    if (raw instanceof Uint8Array) {
-      if (raw.length === 32) {
-        return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
-      }
-      return await crypto.subtle.importKey("raw", raw, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
-    }
-    if (raw.length === 64) {
-      return await crypto.subtle.importKey("raw", Uint8Array.fromHex(raw), {
-        name: "AES-GCM",
-        length: 256
-      }, true, ["encrypt", "decrypt"]);
-    } else {
-      return await crypto.subtle.importKey("raw", Uint8Array.fromHex(hash(raw)), {
-        name: "AES-GCM",
-        length: 256
-      }, true, ["encrypt", "decrypt"]);
-    }
-  } else {
-    return await crypto.subtle.generateKey({
-      name: "AES-GCM",
-      length: 256
-    }, true, ["encrypt", "decrypt"]);
-  }
-}
-async function exportKey(key, format) {
-  const buffer = await crypto.subtle.exportKey(format, key);
-  return new Uint8Array(buffer).toBase64();
-}
-async function generateECDSAKeyPair() {
-  return await crypto.subtle.generateKey({
-    name: "ECDSA",
-    namedCurve: "P-256"
-  }, true, ["sign", "verify"]);
-}
-async function exportJWK(key) {
-  return await crypto.subtle.exportKey("jwk", key);
-}
-async function importJWK(jwk, usage) {
-  return await crypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, true, usage);
-}
-async function sign(message, key) {
-  const data = new TextEncoder().encode(message);
-  const signature = await crypto.subtle.sign({
-    name: "ECDSA",
-    hash: { name: "SHA-256" }
-  }, key, data);
-  return new Uint8Array(signature);
-}
-async function verifySign(message, signature, key) {
-  const data = new TextEncoder().encode(message);
-  return await crypto.subtle.verify({
-    name: "ECDSA",
-    hash: { name: "SHA-256" }
-  }, key, signature, data);
-}
-async function cipher(text, key) {
-  const encoder = new TextEncoder;
-  const data = encoder.encode(text);
-  const iv = crypto.getRandomValues(new Uint8Array(12));
-  const buffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, await cryptoKey(key), data);
-  return {
-    text: new Uint8Array(buffer).toHex(),
-    iv,
-    buffer
-  };
-}
-async function decipher(cipher2, key) {
-  const decoder = new TextDecoder;
-  const buffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv: cipher2.iv }, await cryptoKey(key), Uint8Array.fromHex(cipher2.text));
-  const data = decoder.decode(buffer);
-  return data;
-}
-async function keypair() {
-  return await crypto.subtle.generateKey({
-    name: "RSA-OAEP",
-    modulusLength: 2048,
-    publicExponent: new Uint8Array([1, 0, 1]),
-    hash: { name: "SHA-256" }
-  }, true, ["encrypt", "decrypt"]);
-}
-async function encrypt(text, key) {
-  const data = new TextEncoder().encode(text);
-  const buffer = await crypto.subtle.encrypt({ name: "RSA-OAEP" }, key, data);
-  return new Uint8Array(buffer);
-}
-async function decrypt(text, key) {
-  const buffer = await crypto.subtle.decrypt({ name: "RSA-OAEP" }, key, text);
-  const data = new TextDecoder().decode(buffer);
-  return data;
-}
-export {
-  verifySign,
-  sign,
-  keypair,
-  importJWK,
-  hash,
-  generateECDSAKeyPair,
-  exportKey,
-  exportJWK,
-  encrypt,
-  decrypt,
-  decipher,
-  cryptoKey,
-  cipher
-};
+// @bun
+var c=Object.create;var{getPrototypeOf:s,defineProperty:o,getOwnPropertyNames:p}=Object;var u=Object.prototype.hasOwnProperty;var A=(e,t,r)=>{r=e!=null?c(s(e)):{};let n=t||!e||!e.__esModule?o(r,"default",{value:e,enumerable:!0}):r;for(let a of p(e))if(!u.call(n,a))o(n,a,{get:()=>e[a],enumerable:!0});return n};var d=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var m=(e,t)=>{for(var r in t)o(e,r,{get:t[r],enumerable:!0,configurable:!0,set:(n)=>t[r]=()=>n})};var x=import.meta.require;function f(e,t){return new Bun.CryptoHasher("sha256",t).update(e).digest("hex")}async function i(e){if(e){if(e instanceof CryptoKey)return e;if(e instanceof Uint8Array){if(e.length===32)return await crypto.subtle.importKey("raw",e,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);return await crypto.subtle.importKey("raw",e,{name:"AES-GCM",length:256},!0,["encrypt","decrypt"])}if(e.length===64)return await crypto.subtle.importKey("raw",Uint8Array.fromHex(e),{name:"AES-GCM",length:256},!0,["encrypt","decrypt"]);else return await crypto.subtle.importKey("raw",Uint8Array.fromHex(f(e)),{name:"AES-GCM",length:256},!0,["encrypt","decrypt"])}else return await crypto.subtle.generateKey({name:"AES-GCM",length:256},!0,["encrypt","decrypt"])}async function C(e,t){let r=await crypto.subtle.exportKey(t,e);return new Uint8Array(r).toBase64()}async function K(){return await crypto.subtle.generateKey({name:"ECDSA",namedCurve:"P-256"},!0,["sign","verify"])}async function l(e){return await crypto.subtle.exportKey("jwk",e)}async function w(e,t){return await crypto.subtle.importKey("jwk",e,{name:"ECDSA",namedCurve:"P-256"},!0,t)}async function b(e,t){let r=new TextEncoder().encode(e),n=await crypto.subtle.sign({name:"ECDSA",hash:{name:"SHA-256"}},t,r);return new Uint8Array(n)}async function h(e,t,r){let n=new TextEncoder().encode(e);return await crypto.subtle.verify({name:"ECDSA",hash:{name:"SHA-256"}},r,t,n)}async function E(e,t){let n=new TextEncoder().encode(e),a=crypto.getRandomValues(new Uint8Array(12)),y=await crypto.subtle.encrypt({name:"AES-GCM",iv:a},await i(t),n);return{text:new Uint8Array(y).toHex(),iv:a,buffer:y}}async function S(e,t){let r=new TextDecoder,n=await crypto.subtle.decrypt({name:"AES-GCM",iv:e.iv},await i(t),Uint8Array.fromHex(e.text));return r.decode(n)}async function P(){return await crypto.subtle.generateKey({name:"RSA-OAEP",modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:{name:"SHA-256"}},!0,["encrypt","decrypt"])}async function U(e,t){let r=new TextEncoder().encode(e),n=await crypto.subtle.encrypt({name:"RSA-OAEP"},t,r);return new Uint8Array(n)}async function v(e,t){let r=await crypto.subtle.decrypt({name:"RSA-OAEP"},t,e);return new TextDecoder().decode(r)}export{h as verifySign,b as sign,P as keypair,w as importJWK,f as hash,K as generateECDSAKeyPair,C as exportKey,l as exportJWK,U as encrypt,v as decrypt,S as decipher,i as cryptoKey,E as cipher};