lakutata 0.0.1

package/build/chunk-O2NOYN65.js

@@ -0,0 +1,54 @@
+import { createTokenizer } from './chunk-26TQI22I.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+
+// src/lib/ioc/Utils.ts
+init_esm_shims();
+function flatten(array) {
+  const result = [];
+  array.forEach((arr) => {
+    arr.forEach((item) => {
+      result.push(item);
+    });
+  });
+  return result;
+}
+__name(flatten, "flatten");
+function nameValueToObject(name, value) {
+  let obj = name;
+  if (typeof obj === "string" || typeof obj === "symbol")
+    return { [name]: value };
+  return obj;
+}
+__name(nameValueToObject, "nameValueToObject");
+function last(arr) {
+  return arr[arr.length - 1];
+}
+__name(last, "last");
+function isClass(fn) {
+  if (typeof fn !== "function") {
+    return false;
+  }
+  const tokenizer = createTokenizer(fn.toString());
+  const first = tokenizer.next();
+  if (first.type === "class")
+    return true;
+  const second = tokenizer.next();
+  if (first.type === "function" && second.value) {
+    if (second.value[0] === second.value[0].toUpperCase())
+      return true;
+  }
+  return false;
+}
+__name(isClass, "isClass");
+function isFunction(val) {
+  return typeof val === "function";
+}
+__name(isFunction, "isFunction");
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+__name(uniq, "uniq");
+
+export { flatten, isClass, isFunction, last, nameValueToObject, uniq };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/build/chunk-OAD22QZQ.js

@@ -0,0 +1,6 @@
+import { init_esm_shims } from './chunk-5NK7E2HA.js';
+
+// src/types/InjectionProperties.ts
+init_esm_shims();
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy90eXBlcy9JbmplY3Rpb25Qcm9wZXJ0aWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBJbmplY3Rpb25Qcm9wZXJ0aWVzID0gUmVjb3JkPHN0cmluZywgYW55PlxuIl19

package/build/chunk-OIFILR4I.js

@@ -0,0 +1,125 @@
+import { RESOLVER, asClass, asFunction } from './chunk-LBL5XNWX.js';
+import { isFunction, isClass } from './chunk-O2NOYN65.js';
+import { Lifetime } from './chunk-MEKICSEL.js';
+import { camelCase } from './chunk-HODDA5D5.js';
+import { init_esm_shims, __name } from './chunk-5NK7E2HA.js';
+import { pathToFileURL } from 'url';
+
+// src/lib/ioc/LoadModules.ts
+init_esm_shims();
+var nameFormatters = {
+  camelCase: (s) => camelCase(s)
+};
+function loadModules(dependencies, globPatterns, opts) {
+  opts ??= {};
+  const container = dependencies.container;
+  opts = optsWithDefaults(opts);
+  const modules = dependencies.listModules(globPatterns, opts);
+  if (opts.esModules) {
+    return loadEsModules(dependencies, container, modules, opts);
+  } else {
+    const result = modules.map((m) => {
+      const loaded = dependencies.require(m.path);
+      return parseLoadedModule(loaded, m);
+    });
+    return registerModules(result, container, modules, opts);
+  }
+}
+__name(loadModules, "loadModules");
+async function loadEsModules(dependencies, container, modules, opts) {
+  const importPromises = [];
+  for (const m of modules) {
+    const fileUrl = pathToFileURL(m.path).toString();
+    importPromises.push(dependencies.require(fileUrl));
+  }
+  const imports = await Promise.all(importPromises);
+  const result = [];
+  for (let i = 0; i < modules.length; i++)
+    result.push(parseLoadedModule(imports[i], modules[i]));
+  return registerModules(result, container, modules, opts);
+}
+__name(loadEsModules, "loadEsModules");
+function parseLoadedModule(loaded, m) {
+  const items = [];
+  if (!loaded)
+    return items;
+  if (isFunction(loaded)) {
+    items.push({
+      name: m.name,
+      path: m.path,
+      value: loaded,
+      opts: m.opts
+    });
+    return items;
+  }
+  if (loaded.default && isFunction(loaded.default)) {
+    items.push({
+      name: m.name,
+      path: m.path,
+      value: loaded.default,
+      opts: m.opts
+    });
+  }
+  for (const key of Object.keys(loaded)) {
+    if (key === "default") {
+      continue;
+    }
+    if (isFunction(loaded[key]) && RESOLVER in loaded[key]) {
+      items.push({
+        name: key,
+        path: m.path,
+        value: loaded[key],
+        opts: m.opts
+      });
+    }
+  }
+  return items;
+}
+__name(parseLoadedModule, "parseLoadedModule");
+function registerModules(modulesToRegister, container, modules, opts) {
+  modulesToRegister.reduce((acc, cur) => acc.concat(cur), []).filter((x) => x).forEach(registerDescriptor.bind(null, container, opts));
+  return {
+    loadedModules: modules
+  };
+}
+__name(registerModules, "registerModules");
+function optsWithDefaults(opts, container) {
+  return {
+    // Does a somewhat-deep merge on the registration options.
+    resolverOptions: {
+      lifetime: Lifetime.TRANSIENT,
+      ...opts && opts.resolverOptions
+    },
+    ...opts
+  };
+}
+__name(optsWithDefaults, "optsWithDefaults");
+function registerDescriptor(container, opts, moduleDescriptor) {
+  const inlineConfig = moduleDescriptor.value[RESOLVER];
+  let name = inlineConfig && inlineConfig.name;
+  if (!name) {
+    name = moduleDescriptor.name;
+    let formatter = opts.formatName;
+    if (formatter) {
+      if (typeof formatter === "string")
+        formatter = nameFormatters[formatter];
+      if (formatter)
+        name = formatter(name, moduleDescriptor);
+    }
+  }
+  let moduleDescriptorOpts = moduleDescriptor.opts;
+  if (typeof moduleDescriptorOpts === "string")
+    moduleDescriptorOpts = { lifetime: moduleDescriptorOpts };
+  const regOpts = {
+    ...opts.resolverOptions,
+    ...moduleDescriptorOpts,
+    ...inlineConfig
+  };
+  const reg = regOpts.register ? regOpts.register : isClass(moduleDescriptor.value) ? asClass : asFunction;
+  container.register(name, reg(moduleDescriptor.value, regOpts));
+}
+__name(registerDescriptor, "registerDescriptor");
+
+export { loadModules };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/ioc/LoadModules.ts"],"names":[],"mappings":"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","sourcesContent":["import 'reflect-metadata'\nimport {pathToFileURL} from 'url'\nimport {ModuleDescriptor, GlobWithOptions, listModules} from './ListModules.js'\nimport {Lifetime} from './Lifetime.js'\nimport {\n    RESOLVER,\n    asClass,\n    asFunction,\n    BuildResolverOptions, BuildResolver\n} from './Resolvers.js'\nimport {IDependencyInjectionContainer} from './DependencyInjectionContainer.js'\nimport {isClass, isFunction} from './Utils.js'\nimport {camelCase} from 'camel-case'\n\n/**\n * 模块的元数据以及加载的模块本身\n * @interface LoadedModuleDescriptor\n */\nexport interface LoadedModuleDescriptor extends ModuleDescriptor {\n    value: unknown\n}\n\n/**\n * 调用loadModules()时的选项\n * @interface LoadModulesOptions\n */\nexport interface LoadModulesOptions<ESM extends boolean = false> {\n    cwd?: string\n    formatName?: NameFormatter | BuiltInNameFormatters\n    resolverOptions?: BuildResolverOptions<any>\n    esModules?: ESM\n}\n\n/**\n * 在使用loadModules()时，名称格式化的选项\n * @type BuiltInNameFormatters\n */\nexport type BuiltInNameFormatters = 'camelCase'\n\n/**\n * 接受正在加载的模块的文件名和模块描述符，并返回一个字符串，用于在容器中注册模块\n * descriptor.name与name相同\n * @type {NameFormatter}\n */\nexport type NameFormatter = (\n    name: string,\n    descriptor: LoadedModuleDescriptor\n) => string\n\n/**\n * loadModules的依赖项\n */\nexport interface LoadModulesDeps {\n    listModules: typeof listModules\n    container: IDependencyInjectionContainer\n\n    require(path: string): any | Promise<any>\n}\n\nconst nameFormatters: Record<string, NameFormatter> = {\n    camelCase: (s: string) => camelCase(s)\n}\n\n/**\n * 加载的模块列表\n */\nexport interface LoadModulesResult {\n    loadedModules: Array<ModuleDescriptor>\n}\n\nexport function loadModules<ESM extends boolean = false>(\n    dependencies: LoadModulesDeps,\n    globPatterns: string | Array<string | GlobWithOptions>,\n    opts?: LoadModulesOptions<ESM>\n): ESM extends true ? Promise<LoadModulesResult> : LoadModulesResult\n/**\n * 给定一个 glob 字符串数组，将在它们上调用 require，并将容器作为第一个参数调用其默认导出的函数\n *\n * @param  {IDependencyInjectionContainer} dependencies.container\n * 要安装加载的模块的容器\n *\n * @param  {Function} dependencies.listModules\n * 用于列出模块的listModules函数\n *\n * @param  {Function} dependencies.require\n * require函数 - 这是一个依赖项，因为它使得测试更加容易\n *\n * @param  {String[]} globPatterns\n * 加载模块时要使用的 glob 数组\n *\n * @param  {Object} opts\n * 传递给listModules的选项，例如{ cwd: '...' }\n *\n * @param  {(string, ModuleDescriptor) => string} opts.formatName\n * 用于格式化模块在容器中注册的名称\n *\n * @param  {boolean} opts.esModules\n * 将其设置为true以使用Node的原生ECMAScript模块\n *\n * @return {Object}\n * 返回描述结果的对象\n */\nexport function loadModules<ESM extends boolean>(\n    dependencies: LoadModulesDeps,\n    globPatterns: string | Array<string | GlobWithOptions>,\n    opts?: LoadModulesOptions<ESM>\n): Promise<LoadModulesResult> | LoadModulesResult {\n    opts ??= {}\n    const container: IDependencyInjectionContainer = dependencies.container\n    opts = optsWithDefaults(opts, container)\n    const modules: ModuleDescriptor[] = dependencies.listModules(globPatterns, opts)\n    if (opts.esModules) {\n        return loadEsModules(dependencies, container, modules, opts)\n    } else {\n        const result: LoadedModuleDescriptor[][] = modules.map((m: ModuleDescriptor) => {\n            const loaded = dependencies.require(m.path)\n            return parseLoadedModule(loaded, m)\n        })\n        return registerModules(result, container, modules, opts)\n    }\n}\n\n/**\n * 使用原生的ES6模块和异步的import()加载模块\n * @param {IDependencyInjectionContainer} container\n * @param {ModuleDescriptor[]} modules\n * @param {LoadModulesOptions} opts\n */\nasync function loadEsModules<ESM extends boolean>(\n    dependencies: LoadModulesDeps,\n    container: IDependencyInjectionContainer,\n    modules: ModuleDescriptor[],\n    opts: LoadModulesOptions<ESM>\n): Promise<LoadModulesResult> {\n    const importPromises: any[] = []\n    for (const m of modules) {\n        const fileUrl = pathToFileURL(m.path).toString()\n        importPromises.push(dependencies.require(fileUrl))\n    }\n    const imports: any[] = await Promise.all(importPromises)\n    const result: any[] = []\n    for (let i = 0; i < modules.length; i++) result.push(parseLoadedModule(imports[i], modules[i]))\n    return registerModules(result, container, modules, opts)\n}\n\n/**\n * 解析已经被引入的模块\n * @param {any} loaded\n * @param {ModuleDescriptor} m\n */\nfunction parseLoadedModule(\n    loaded: any,\n    m: ModuleDescriptor\n): Array<LoadedModuleDescriptor> {\n    const items: Array<LoadedModuleDescriptor> = []\n    if (!loaded) return items\n    if (isFunction(loaded)) {\n        items.push({\n            name: m.name,\n            path: m.path,\n            value: loaded,\n            opts: m.opts\n        })\n        return items\n    }\n    if (loaded.default && isFunction(loaded.default)) {\n        // ES6 default export\n        items.push({\n            name: m.name,\n            path: m.path,\n            value: loaded.default,\n            opts: m.opts\n        })\n    }\n    // loop through non-default exports, but require the RESOLVER property set for\n    // it to be a valid service module export.\n    for (const key of Object.keys(loaded)) {\n        if (key === 'default') {\n            // default case handled separately due to its different name (file name)\n            continue\n        }\n        if (isFunction(loaded[key]) && RESOLVER in loaded[key]) {\n            items.push({\n                name: key,\n                path: m.path,\n                value: loaded[key],\n                opts: m.opts\n            })\n        }\n    }\n    return items\n}\n\n/**\n * 注册模块\n * @param {ModuleDescriptorVal[][]} modulesToRegister\n * @param {IDependencyInjectionContainer} container\n * @param {ModuleDescriptor[]} modules\n * @param {LoadModulesOptions} opts\n */\nfunction registerModules<ESM extends boolean>(\n    modulesToRegister: LoadedModuleDescriptor[][],\n    container: IDependencyInjectionContainer,\n    modules: ModuleDescriptor[],\n    opts: LoadModulesOptions<ESM>\n): LoadModulesResult {\n    modulesToRegister\n        .reduce((acc, cur) => acc.concat(cur), [])\n        .filter((x) => x)\n        .forEach(registerDescriptor.bind(null, container, opts))\n    return {\n        loadedModules: modules\n    }\n}\n\n/**\n * 返回一个具有应用默认值的新选项对象\n */\nfunction optsWithDefaults<ESM extends boolean = false>(\n    opts: Partial<LoadModulesOptions<ESM>> | undefined,\n    container: IDependencyInjectionContainer\n): LoadModulesOptions<ESM> {\n    return {\n        // Does a somewhat-deep merge on the registration options.\n        resolverOptions: {\n            lifetime: Lifetime.TRANSIENT,\n            ...(opts && opts.resolverOptions)\n        },\n        ...opts\n    }\n}\n\n/**\n * 给定一个模块描述符，读取它并将其值注册到容器中\n * @param {IDependencyInjectionContainer} container\n * @param {LoadModulesOptions} opts\n * @param {ModuleDescriptor} moduleDescriptor\n */\nfunction registerDescriptor<ESM extends boolean = false>(\n    container: IDependencyInjectionContainer,\n    opts: LoadModulesOptions<ESM>,\n    moduleDescriptor: LoadedModuleDescriptor & { value: any }\n): void {\n    const inlineConfig = moduleDescriptor.value[RESOLVER]\n    let name = inlineConfig && inlineConfig.name\n    if (!name) {\n        name = moduleDescriptor.name\n        let formatter = opts.formatName\n        if (formatter) {\n            if (typeof formatter === 'string') formatter = nameFormatters[formatter]\n            if (formatter) name = formatter(name, moduleDescriptor)\n        }\n    }\n    let moduleDescriptorOpts = moduleDescriptor.opts\n    if (typeof moduleDescriptorOpts === 'string') moduleDescriptorOpts = {lifetime: moduleDescriptorOpts}\n    const regOpts: BuildResolver<any> = {\n        ...opts.resolverOptions,\n        ...moduleDescriptorOpts,\n        ...inlineConfig\n    }\n    const reg: Function = regOpts.register\n        ? regOpts.register\n        : isClass(moduleDescriptor.value)\n            ? asClass\n            : asFunction\n    container.register(name, reg(moduleDescriptor.value, regOpts))\n}\n"]}

package/build/chunk-OJGBPS2B.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkHBPRX3WA_cjs = require('./chunk-HBPRX3WA.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/exceptions/crypto/asymmetric/InvalidAsymmetricEncryptPrivateKeyException.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _InvalidAsymmetricEncryptPrivateKeyException = class _InvalidAsymmetricEncryptPrivateKeyException extends chunkHBPRX3WA_cjs.Exception {
+  errno = "E_INVALID_ASYMMETRIC_ENCRYPT_PRIVATE_KEY";
+};
+chunkGGY7LCMQ_cjs.__name(_InvalidAsymmetricEncryptPrivateKeyException, "InvalidAsymmetricEncryptPrivateKeyException");
+var InvalidAsymmetricEncryptPrivateKeyException = _InvalidAsymmetricEncryptPrivateKeyException;
+
+exports.InvalidAsymmetricEncryptPrivateKeyException = InvalidAsymmetricEncryptPrivateKeyException;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9leGNlcHRpb25zL2NyeXB0by9hc3ltbWV0cmljL0ludmFsaWRBc3ltbWV0cmljRW5jcnlwdFByaXZhdGVLZXlFeGNlcHRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUE7QUFFTyxJQUFNLCtDQUFOLE1BQU0scURBQW9ELFVBQVU7QUFBQSxFQUNoRSxRQUF5QjtBQUNwQztBQUYyRTtBQUFwRSxJQUFNLDhDQUFOIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtFeGNlcHRpb259IGZyb20gJy4uLy4uLy4uL2xpYi9iYXNlL2Fic3RyYWN0cy9FeGNlcHRpb24uanMnXG5cbmV4cG9ydCBjbGFzcyBJbnZhbGlkQXN5bW1ldHJpY0VuY3J5cHRQcml2YXRlS2V5RXhjZXB0aW9uIGV4dGVuZHMgRXhjZXB0aW9uIHtcbiAgICBwdWJsaWMgZXJybm86IG51bWJlciB8IHN0cmluZyA9ICdFX0lOVkFMSURfQVNZTU1FVFJJQ19FTkNSWVBUX1BSSVZBVEVfS0VZJ1xufVxuIl19

package/build/chunk-OMPATIMZ.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var chunkPOE7A7NF_cjs = require('./chunk-POE7A7NF.cjs');
+var chunkMNDBRDT2_cjs = require('./chunk-MNDBRDT2.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+var crypto = require('crypto');
+
+// src/lib/crypto/RSA.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _RSA = class _RSA extends chunkPOE7A7NF_cjs.AsymmetricEncryption {
+  options = {
+    signatureAlgorithm: "sha256"
+  };
+  createPrivateKey(privateKeyString) {
+    return crypto.createPrivateKey(privateKeyString);
+  }
+  createPublicKey(publicKeyString) {
+    return crypto.createPublicKey(publicKeyString);
+  }
+  decrypt(encryptedMessage) {
+    return crypto.privateDecrypt(this.privateKey, Buffer.from(encryptedMessage, "base64")).toString();
+  }
+  encrypt(message) {
+    return crypto.publicEncrypt(this.publicKey, Buffer.from(message)).toString("base64");
+  }
+  async generateKeyPair(options) {
+    return new Promise((resolve, reject) => {
+      options = options ? options : {};
+      options.modulusLength = options.modulusLength ? options.modulusLength : 1024;
+      options.publicExponent = options.publicExponent ? options.publicExponent : 65537;
+      options.publicKeyEncoding = options.publicKeyEncoding ? options.publicKeyEncoding : {};
+      options.publicKeyEncoding.type = options.publicKeyEncoding.type ? options.publicKeyEncoding.type : "pkcs1";
+      options.publicKeyEncoding.format = options.publicKeyEncoding.format ? options.publicKeyEncoding.format : "pem";
+      options.privateKeyEncoding = options.privateKeyEncoding ? options.privateKeyEncoding : {};
+      options.privateKeyEncoding.format = options.privateKeyEncoding.format ? options.privateKeyEncoding.format : "pem";
+      options.privateKeyEncoding.type = options.privateKeyEncoding.type ? options.privateKeyEncoding.type : "pkcs1";
+      return crypto.generateKeyPair("rsa", chunkMNDBRDT2_cjs.As(options), (err, publicKey, privateKey) => {
+        if (err)
+          return reject(err);
+        return resolve({
+          publicKey: typeof publicKey === "string" ? publicKey : publicKey.toString("base64"),
+          privateKey: typeof privateKey === "string" ? privateKey : privateKey.toString("base64")
+        });
+      });
+    });
+  }
+  sign(message) {
+    return crypto.sign(this.options.signatureAlgorithm, Buffer.from(message), this.privateKey).toString("base64");
+  }
+  verify(message, sign2) {
+    return crypto.verify(this.options.signatureAlgorithm, Buffer.from(message), this.publicKey, Buffer.from(sign2, "base64"));
+  }
+  static async generateKeyPair(options) {
+    return super.generateKeyPair(options);
+  }
+  static async loadKeyPair(keyPair, options) {
+    return chunkMNDBRDT2_cjs.As(super.loadKeyPair(keyPair, options));
+  }
+  static async loadPublicKey(inp, options) {
+    return super.loadPublicKey(inp, options);
+  }
+  static async loadPrivateKey(inp, options) {
+    return super.loadPrivateKey(inp, options);
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_RSA, "RSA");
+var RSA = _RSA;
+
+exports.RSA = RSA;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/crypto/RSA.ts"],"names":["sign"],"mappings":";;;;;;;;;;;;AAAA;AAMA;AAAA,EACI;AAAA,EACA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AA6CA,IAAM,OAAN,MAAM,aAAY,qBAAqB;AAAA,EAEhC,UAAsB;AAAA,IAC5B,oBAAoB;AAAA,EACxB;AAAA,EAEU,iBAAiB,kBAAqC;AAC5D,WAAO,iBAAiB,gBAAgB;AAAA,EAC5C;AAAA,EAEU,gBAAgB,iBAAoC;AAC1D,WAAO,gBAAgB,eAAe;AAAA,EAC1C;AAAA,EAEU,QAAQ,kBAAkC;AAChD,WAAO,eAAe,KAAK,YAAY,OAAO,KAAK,kBAAkB,QAAQ,CAAC,EAAE,SAAS;AAAA,EAC7F;AAAA,EAEU,QAAQ,SAAyB;AACvC,WAAO,cAAc,KAAK,WAAW,OAAO,KAAK,OAAO,CAAC,EAAE,SAAS,QAAQ;AAAA,EAChF;AAAA,EAEA,MAAgB,gBAAgB,SAAmE;AAC/F,WAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AACpC,gBAAU,UAAU,UAAU,CAAC;AAC/B,cAAQ,gBAAgB,QAAQ,gBAAgB,QAAQ,gBAAgB;AACxE,cAAQ,iBAAiB,QAAQ,iBAAiB,QAAQ,iBAAiB;AAC3E,cAAQ,oBAAoB,QAAQ,oBAAoB,QAAQ,oBAAoB,CAAC;AACrF,cAAQ,kBAAkB,OAAO,QAAQ,kBAAkB,OAAO,QAAQ,kBAAkB,OAAO;AACnG,cAAQ,kBAAkB,SAAS,QAAQ,kBAAkB,SAAS,QAAQ,kBAAkB,SAAS;AACzG,cAAQ,qBAAqB,QAAQ,qBAAqB,QAAQ,qBAAqB,CAAC;AACxF,cAAQ,mBAAmB,SAAS,QAAQ,mBAAmB,SAAS,QAAQ,mBAAmB,SAAS;AAC5G,cAAQ,mBAAmB,OAAO,QAAQ,mBAAmB,OAAO,QAAQ,mBAAmB,OAAO;AACtG,aAAO,gBAAgB,OAAO,GAAQ,OAAO,GAAG,CAAC,KAAmB,WAA4B,eAAsC;AAClI,YAAI;AAAK,iBAAO,OAAO,GAAG;AAC1B,eAAO,QAAQ;AAAA,UACX,WAAW,OAAO,cAAc,WAAW,YAAY,UAAU,SAAS,QAAQ;AAAA,UAClF,YAAY,OAAO,eAAe,WAAW,aAAa,WAAW,SAAS,QAAQ;AAAA,QAC1F,CAAC;AAAA,MACL,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AAAA,EAEU,KAAK,SAAyB;AACpC,WAAO,KAAK,KAAK,QAAQ,oBAAoB,OAAO,KAAK,OAAO,GAAG,KAAK,UAAU,EAAE,SAAS,QAAQ;AAAA,EACzG;AAAA,EAEU,OAAO,SAAiBA,OAAuB;AACrD,WAAO,OAAO,KAAK,QAAQ,oBAAoB,OAAO,KAAK,OAAO,GAAG,KAAK,WAAW,OAAO,KAAKA,OAAM,QAAQ,CAAC;AAAA,EACpH;AAAA,EAEA,aAAoB,gBAAgB,SAAmE;AACnG,WAAO,MAAM,gBAAgB,OAAO;AAAA,EACxC;AAAA,EAEA,aAAoB,YAAkD,SAAsC,SAAkC;AAC1I,WAAO,GAAM,MAAM,YAAiB,SAAS,OAAO,CAAC;AAAA,EACzD;AAAA,EAEA,aAAoB,cAAc,KAAwB,SAA2D;AACjH,WAAO,MAAM,cAAc,KAAK,OAAO;AAAA,EAC3C;AAAA,EAEA,aAAoB,eAAe,KAAwB,SAA4D;AACnH,WAAO,MAAM,eAAe,KAAK,OAAO;AAAA,EAC5C;AAEJ;AAnE8C;AAAvC,IAAM,MAAN","sourcesContent":["import 'reflect-metadata'\nimport {\n    AsymmetricEncryption,\n    AsymmetricEncryptionKeyPair, AsymmetricEncryptionPrivate,\n    AsymmetricEncryptionPublic\n} from '../base/abstracts/AsymmetricEncryption.js'\nimport {\n    createPrivateKey,\n    createPublicKey,\n    generateKeyPair,\n    KeyObject,\n    privateDecrypt,\n    publicEncrypt,\n    sign,\n    verify\n} from 'crypto'\nimport {As} from '../../Utilities.js'\nimport {PathLike} from 'fs'\n\nexport interface RSAKeyPairOptions {\n    /**\n     * 密钥长度，以bit为单位\n     * @default 1024\n     */\n    modulusLength?: number\n    /**\n     * 公钥指数\n     * @default 0x10001\n     */\n    publicExponent?: number | undefined\n    publicKeyEncoding?: {\n        /**\n         * @default pkcs1\n         */\n        type?: 'pkcs1' | 'spki'\n        /**\n         * @default pem\n         */\n        format?: 'pem' | 'der'\n    }\n    privateKeyEncoding?: {\n        /**\n         * @default pem\n         */\n        format?: 'pem' | 'der'\n        /**\n         * @default pkcs1\n         */\n        type?: 'pkcs1' | 'pkcs8';\n    }\n}\n\nexport interface RSAOptions {\n    /**\n     * 签名或验签时所使用的哈希算法\n     * @default sha256\n     */\n    signatureAlgorithm?: string\n}\n\nexport class RSA extends AsymmetricEncryption {\n\n    protected options: RSAOptions = {\n        signatureAlgorithm: 'sha256'\n    }\n\n    protected createPrivateKey(privateKeyString: string): KeyObject {\n        return createPrivateKey(privateKeyString)\n    }\n\n    protected createPublicKey(publicKeyString: string): KeyObject {\n        return createPublicKey(publicKeyString)\n    }\n\n    protected decrypt(encryptedMessage: string): string {\n        return privateDecrypt(this.privateKey, Buffer.from(encryptedMessage, 'base64')).toString()\n    }\n\n    protected encrypt(message: string): string {\n        return publicEncrypt(this.publicKey, Buffer.from(message)).toString('base64')\n    }\n\n    protected async generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        return new Promise((resolve, reject) => {\n            options = options ? options : {}\n            options.modulusLength = options.modulusLength ? options.modulusLength : 1024\n            options.publicExponent = options.publicExponent ? options.publicExponent : 0x10001\n            options.publicKeyEncoding = options.publicKeyEncoding ? options.publicKeyEncoding : {}\n            options.publicKeyEncoding.type = options.publicKeyEncoding.type ? options.publicKeyEncoding.type : 'pkcs1'\n            options.publicKeyEncoding.format = options.publicKeyEncoding.format ? options.publicKeyEncoding.format : 'pem'\n            options.privateKeyEncoding = options.privateKeyEncoding ? options.privateKeyEncoding : {}\n            options.privateKeyEncoding.format = options.privateKeyEncoding.format ? options.privateKeyEncoding.format : 'pem'\n            options.privateKeyEncoding.type = options.privateKeyEncoding.type ? options.privateKeyEncoding.type : 'pkcs1'\n            return generateKeyPair('rsa', As<any>(options), (err: Error | null, publicKey: string | Buffer, privateKey: string | Buffer): void => {\n                if (err) return reject(err)\n                return resolve({\n                    publicKey: typeof publicKey === 'string' ? publicKey : publicKey.toString('base64'),\n                    privateKey: typeof privateKey === 'string' ? privateKey : privateKey.toString('base64')\n                })\n            })\n        })\n    }\n\n    protected sign(message: string): string {\n        return sign(this.options.signatureAlgorithm, Buffer.from(message), this.privateKey).toString('base64')\n    }\n\n    protected verify(message: string, sign: string): boolean {\n        return verify(this.options.signatureAlgorithm, Buffer.from(message), this.publicKey, Buffer.from(sign, 'base64'))\n    }\n\n    public static async generateKeyPair(options?: RSAKeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        return super.generateKeyPair(options)\n    }\n\n    public static async loadKeyPair<T extends AsymmetricEncryption = RSA>(keyPair: AsymmetricEncryptionKeyPair, options?: RSAOptions): Promise<T> {\n        return As<T>(super.loadKeyPair<RSA>(keyPair, options))\n    }\n\n    public static async loadPublicKey(inp: PathLike | string, options?: RSAOptions): Promise<AsymmetricEncryptionPublic> {\n        return super.loadPublicKey(inp, options)\n    }\n\n    public static async loadPrivateKey(inp: string | PathLike, options?: RSAOptions): Promise<AsymmetricEncryptionPrivate> {\n        return super.loadPrivateKey(inp, options)\n    }\n\n}\n"]}

package/build/chunk-P3Z7ZEGJ.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkPF2WAZLH_cjs = require('./chunk-PF2WAZLH.cjs');
+var chunkGGY7LCMQ_cjs = require('./chunk-GGY7LCMQ.cjs');
+
+// src/lib/base/async-constructor/AsyncConstructor.ts
+chunkGGY7LCMQ_cjs.init_cjs_shims();
+var _AsyncConstructor = class _AsyncConstructor {
+  constructor(asyncConstructor) {
+    chunkPF2WAZLH_cjs.AppendAsyncConstructor(this, asyncConstructor);
+  }
+};
+chunkGGY7LCMQ_cjs.__name(_AsyncConstructor, "AsyncConstructor");
+var AsyncConstructor = _AsyncConstructor;
+
+exports.AsyncConstructor = AsyncConstructor;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9saWIvYmFzZS9hc3luYy1jb25zdHJ1Y3Rvci9Bc3luY0NvbnN0cnVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBO0FBR08sSUFBTSxvQkFBTixNQUFNLGtCQUFpQjtBQUFBLEVBQzFCLFlBQVksa0JBQTJDO0FBQ25ELDJCQUF1QixNQUFNLGdCQUFnQjtBQUFBLEVBQ2pEO0FBQ0o7QUFKOEI7QUFBdkIsSUFBTSxtQkFBTiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAncmVmbGVjdC1tZXRhZGF0YSdcbmltcG9ydCB7QXBwZW5kQXN5bmNDb25zdHJ1Y3Rvcn0gZnJvbSAnLi9BcHBlbmQuanMnXG5cbmV4cG9ydCBjbGFzcyBBc3luY0NvbnN0cnVjdG9yIHtcbiAgICBjb25zdHJ1Y3Rvcihhc3luY0NvbnN0cnVjdG9yOiAoKSA9PiBQcm9taXNlTGlrZTx2b2lkPikge1xuICAgICAgICBBcHBlbmRBc3luY0NvbnN0cnVjdG9yKHRoaXMsIGFzeW5jQ29uc3RydWN0b3IpXG4gICAgfVxufVxuIl19