mol_crypto_lib 0.0.948 → 0.1.950

package/node.js

@@ -928,58 +928,62 @@ var $;
 "use strict";
 var $;
 (function ($) {
-    const algorithm = {
-        name: 'RSA-OAEP',
-        modulusLength: 1024,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: 'SHA-256',
-    };
-    async function $mol_crypto_cipher_pair() {
-        const pair = await $mol_crypto_native.subtle.generateKey(algorithm, true, ['encrypt', 'decrypt']);
-        return {
-            public: new $mol_crypto_cipher_public(pair.publicKey),
-            private: new $mol_crypto_cipher_private(pair.privateKey),
-        };
+})($ || ($ = {}));
+//mol/dom/context/context.ts
+;
+"use strict";
+var $;
+(function ($) {
+    $.$mol_dom_context = new $node.jsdom.JSDOM('', { url: 'https://localhost/' }).window;
+})($ || ($ = {}));
+//mol/dom/context/context.node.ts
+;
+"use strict";
+var $;
+(function ($) {
+    async function $mol_crypto_secret_id() {
+        const signed = this.$mol_dom_context.localStorage.getItem('$mol_crypto_secret');
+        if (signed === '')
+            return await this.$mol_crypto_secret_id_get();
+        const id = await this.$mol_crypto_secret_id_new();
+        this.$mol_dom_context.localStorage.setItem('$mol_crypto_secret', '');
+        return id;
     }
-    $.$mol_crypto_cipher_pair = $mol_crypto_cipher_pair;
-    class $mol_crypto_cipher_public extends Object {
-        native;
-        static size = 162;
-        constructor(native) {
-            super();
-            this.native = native;
-        }
-        static async from(serial) {
-            return new this(await $mol_crypto_native.subtle.importKey('spki', serial, algorithm, true, ['encrypt']));
-        }
-        async serial() {
-            return await $mol_crypto_native.subtle.exportKey('spki', this.native);
-        }
-        async encrypt(data) {
-            return await $mol_crypto_native.subtle.encrypt(algorithm, this.native, data);
-        }
+    $.$mol_crypto_secret_id = $mol_crypto_secret_id;
+    async function $mol_crypto_secret_id_new() {
+        const cred = await this.$mol_dom_context.navigator.credentials.create({
+            publicKey: {
+                rp: {
+                    name: "$mol_crypto_id",
+                },
+                user: {
+                    id: new Uint8Array([0]),
+                    name: "",
+                    displayName: ""
+                },
+                pubKeyCredParams: [
+                    { type: "public-key", alg: -7 },
+                    { type: "public-key", alg: -257 },
+                ],
+                challenge: new Uint8Array().buffer,
+            },
+        });
+        return $mol_crypto_secret.from(cred.rawId);
     }
-    $.$mol_crypto_cipher_public = $mol_crypto_cipher_public;
-    class $mol_crypto_cipher_private extends Object {
-        native;
-        constructor(native) {
-            super();
-            this.native = native;
-        }
-        static async from(serial) {
-            return new this(await $mol_crypto_native.subtle.importKey('pkcs8', serial, algorithm, true, ['decrypt']));
-        }
-        async serial() {
-            return await $mol_crypto_native.subtle.exportKey('pkcs8', this.native);
-        }
-        async decrypt(data) {
-            return await $mol_crypto_native.subtle.decrypt(algorithm, this.native, data);
-        }
+    $.$mol_crypto_secret_id_new = $mol_crypto_secret_id_new;
+    async function $mol_crypto_secret_id_get() {
+        const cred = await this.$mol_dom_context.navigator.credentials.get({
+            mediation: 'silent',
+            publicKey: {
+                userVerification: 'discouraged',
+                challenge: new Uint8Array().buffer,
+            },
+        });
+        return $mol_crypto_secret.from(cred.rawId);
     }
-    $.$mol_crypto_cipher_private = $mol_crypto_cipher_private;
-    $.$mol_crypto_cipher_ecrypted_size = 128;
+    $.$mol_crypto_secret_id_get = $mol_crypto_secret_id_get;
 })($ || ($ = {}));
-//mol/crypto/cipher/cipher.ts
+//mol/crypto/secret/id/id.ts
 ;
 "use strict";
 var $;
@@ -1031,6 +1035,134 @@ var $;
 ;
 "use strict";
 var $;
+(function ($) {
+    function $mol_base64_ae_encode(buffer) {
+        return $mol_base64_encode(buffer).replace(/\+/g, 'æ').replace(/\//g, 'Æ').replace(/=/g, '');
+    }
+    $.$mol_base64_ae_encode = $mol_base64_ae_encode;
+    function $mol_base64_ae_decode(str) {
+        return $mol_base64_decode(str.replace(/æ/g, '+').replace(/Æ/g, '/'));
+    }
+    $.$mol_base64_ae_decode = $mol_base64_ae_decode;
+})($ || ($ = {}));
+//mol/base64/ae/ae.ts
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_buffer extends DataView {
+        static from(array) {
+            if (typeof array === 'string')
+                array = $mol_base64_ae_decode(array);
+            return new this(array.buffer, array.byteOffset, array.byteLength);
+        }
+        static toString() {
+            return $$.$mol_func_name(this);
+        }
+        getUint48(offset, LE = false) {
+            if (offset % 4) {
+                return this.getUint16(offset, LE) + this.getUint32(offset + 2, LE) * 2 ** 16;
+            }
+            else {
+                return this.getUint32(offset, LE) + this.getUint16(offset + 4, LE) * 2 ** 32;
+            }
+        }
+        setUint48(offset, value, LE = false) {
+            if (offset % 4) {
+                this.setUint16(offset, value & ((1 << 16) - 1), LE);
+                this.setUint32(offset + 2, (value / 2 ** 16) | 0, LE);
+            }
+            else {
+                this.setUint32(offset, value | 0, LE);
+                this.setUint16(offset + 4, (value / 2 ** 32) | 0, LE);
+            }
+        }
+        int8(offset, next) {
+            if (next === undefined)
+                return this.getInt8(offset);
+            if (next >= -(2 ** 7) && next < 2 ** 7)
+                return this.setInt8(offset, next), next;
+            $mol_fail(new Error(`Wrong int8 value ${next}`));
+        }
+        uint8(offset, next) {
+            if (next === undefined)
+                return this.getUint8(offset);
+            if (next >= 0 && next < 2 ** 8)
+                return this.setUint8(offset, next), next;
+            $mol_fail(new Error(`Wrong uint8 value ${next}`));
+        }
+        int16(offset, next) {
+            if (next === undefined)
+                return this.getInt16(offset, !!'LE');
+            if (next >= -(2 ** 15) && next < 2 ** 15)
+                return this.setInt16(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong int16 value ${next}`));
+        }
+        uint16(offset, next) {
+            if (next === undefined)
+                return this.getUint16(offset, !!'LE');
+            if (next >= 0 && next < 2 ** 16)
+                return this.setUint16(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong uint16 value ${next}`));
+        }
+        int32(offset, next) {
+            if (next === undefined)
+                return this.getInt32(offset, !!'LE');
+            if (next >= -(2 ** 31) && next < 2 ** 31)
+                return this.setInt32(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong int32 value ${next}`));
+        }
+        uint32(offset, next) {
+            if (next === undefined)
+                return this.getUint32(offset, !!'LE');
+            if (next >= 0 && next < 2 ** 32)
+                return this.setUint32(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong uint32 value ${next}`));
+        }
+        uint48(offset, next) {
+            if (next === undefined)
+                return this.getUint48(offset, !!'LE');
+            if (next >= 0 && next < 2 ** 48)
+                return this.setUint48(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong uint48 value ${next}`));
+        }
+        int64(offset, next) {
+            if (next === undefined)
+                return this.getBigInt64(offset, !!'LE');
+            if (next >= -(2 ** 63) && next < 2 ** 63)
+                return this.setBigInt64(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong int64 value ${next}`));
+        }
+        uint64(offset, next) {
+            if (next === undefined)
+                return this.getBigUint64(offset, !!'LE');
+            if (next >= 0 && next < 2 ** 64)
+                return this.setBigUint64(offset, next, !!'LE'), next;
+            $mol_fail(new Error(`Wrong uint64 value ${next}`));
+        }
+        float32(offset, next) {
+            if (next !== undefined)
+                this.setFloat32(offset, next, !!'LE');
+            return this.getFloat32(offset, !!'LE');
+        }
+        float64(offset, next) {
+            if (next !== undefined)
+                this.setFloat64(offset, next, !!'LE');
+            return this.getFloat64(offset, !!'LE');
+        }
+        asArray() {
+            return new Uint8Array(this.buffer, this.byteOffset, this.byteLength);
+        }
+        toString() {
+            return $mol_base64_ae_encode(this.asArray());
+        }
+    }
+    $.$mol_buffer = $mol_buffer;
+})($ || ($ = {}));
+//mol/buffer/buffer.ts
+;
+"use strict";
+var $;
 (function ($) {
     function $mol_base64_url_encode(buffer) {
         return $mol_base64_encode(buffer).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
@@ -1045,109 +1177,153 @@ var $;
 ;
 "use strict";
 var $;
+(function ($) {
+    class $mol_wrapper extends $mol_object2 {
+        static wrap;
+        static run(task) {
+            return this.func(task)();
+        }
+        static func(func) {
+            return this.wrap(func);
+        }
+        static get class() {
+            return (Class) => {
+                const construct = (target, args) => new Class(...args);
+                const handler = {
+                    construct: this.func(construct)
+                };
+                handler[Symbol.toStringTag] = Class.name + '#';
+                return new Proxy(Class, handler);
+            };
+        }
+        static get method() {
+            return (obj, name, descr) => {
+                descr.value = this.func(descr.value);
+                return descr;
+            };
+        }
+        static get field() {
+            return (obj, name, descr) => {
+                descr.get = descr.set = this.func(descr.get);
+                return descr;
+            };
+        }
+    }
+    $.$mol_wrapper = $mol_wrapper;
+})($ || ($ = {}));
+//mol/wrapper/wrapper.ts
+;
+"use strict";
+var $;
+(function ($) {
+    class $mol_memo extends $mol_wrapper {
+        static wrap(task) {
+            const store = new WeakMap();
+            return function (next) {
+                if (next === undefined && store.has(this))
+                    return store.get(this);
+                const val = task.call(this, next) ?? next;
+                store.set(this, val);
+                return val;
+            };
+        }
+    }
+    $.$mol_memo = $mol_memo;
+})($ || ($ = {}));
+//mol/memo/memo.ts
+;
+"use strict";
+var $;
 (function ($) {
     const algorithm = {
         name: 'ECDSA',
         hash: 'SHA-256',
         namedCurve: "P-256",
     };
-    async function $mol_crypto_auditor_pair() {
-        const pair = await $mol_crypto_native.subtle.generateKey(algorithm, true, ['sign', 'verify']);
-        return {
-            public: new $mol_crypto_auditor_public(pair.publicKey),
-            private: new $mol_crypto_auditor_private(pair.privateKey),
-        };
+    class $mol_crypto_key extends $mol_buffer {
+        static from(serial) {
+            if (typeof serial === 'string') {
+                serial = new Uint8Array([
+                    ...$mol_base64_url_decode(serial.slice(0, 43)),
+                    ...$mol_base64_url_decode(serial.slice(43, 86)),
+                    ...$mol_base64_url_decode(serial.slice(86, 129)),
+                ]);
+            }
+            return new this(serial.buffer, serial.byteOffset, serial.byteLength);
+        }
+        asArray() {
+            return new Uint8Array(this.buffer, this.byteOffset, this.byteLength);
+        }
+        toString() {
+            const arr = this.asArray();
+            return $mol_base64_url_encode(arr.subarray(0, 32))
+                + $mol_base64_url_encode(arr.subarray(32, 64))
+                + $mol_base64_url_encode(arr.subarray(64));
+        }
     }
-    $.$mol_crypto_auditor_pair = $mol_crypto_auditor_pair;
-    class $mol_crypto_auditor_public extends Object {
-        native;
+    __decorate([
+        $mol_memo.method
+    ], $mol_crypto_key.prototype, "toString", null);
+    $.$mol_crypto_key = $mol_crypto_key;
+    class $mol_crypto_key_public extends $mol_crypto_key {
         static size_str = 86;
         static size_bin = 64;
-        constructor(native) {
-            super();
-            this.native = native;
-        }
-        static async from(serial) {
-            if (typeof serial !== 'string') {
-                serial = $mol_base64_url_encode(serial.subarray(0, 32))
-                    + $mol_base64_url_encode(serial.subarray(32, 64));
-            }
-            return new this(await $mol_crypto_native.subtle.importKey('jwk', {
+        async native() {
+            const str = this.toString();
+            return $mol_crypto_native.subtle.importKey('jwk', {
                 crv: "P-256",
                 ext: true,
                 key_ops: ['verify'],
                 kty: "EC",
-                x: serial.slice(0, 43),
-                y: serial.slice(43, 86),
-            }, algorithm, true, ['verify']));
-        }
-        async serial() {
-            const { x, y } = await $mol_crypto_native.subtle.exportKey('jwk', this.native);
-            return x + y;
-        }
-        async toArray() {
-            const { x, y, d } = await $mol_crypto_native.subtle.exportKey('jwk', this.native);
-            return new Uint8Array([
-                ...$mol_base64_url_decode(x),
-                ...$mol_base64_url_decode(y),
-            ]);
+                x: str.slice(0, 43),
+                y: str.slice(43, 86),
+            }, algorithm, true, ['verify']);
         }
         async verify(data, sign) {
-            return await $mol_crypto_native.subtle.verify(algorithm, this.native, sign, data);
+            return await $mol_crypto_native.subtle.verify(algorithm, await this.native(), sign, data);
         }
     }
-    $.$mol_crypto_auditor_public = $mol_crypto_auditor_public;
-    class $mol_crypto_auditor_private extends Object {
-        native;
+    __decorate([
+        $mol_memo.method
+    ], $mol_crypto_key_public.prototype, "native", null);
+    $.$mol_crypto_key_public = $mol_crypto_key_public;
+    class $mol_crypto_key_private extends $mol_crypto_key {
         static size_str = 129;
         static size_bin = 96;
-        constructor(native) {
-            super();
-            this.native = native;
+        static size_sign = 64;
+        static async generate() {
+            const pair = await $mol_crypto_native.subtle.generateKey(algorithm, true, ['sign', 'verify']);
+            const { x, y, d } = await $mol_crypto_native.subtle.exportKey('jwk', pair.privateKey);
+            return this.from(x + y + d);
         }
-        static async from(serial) {
-            if (typeof serial !== 'string') {
-                serial = $mol_base64_url_encode(serial.subarray(0, 32))
-                    + $mol_base64_url_encode(serial.subarray(32, 64))
-                    + $mol_base64_url_encode(serial.subarray(64));
-            }
-            return new this(await $mol_crypto_native.subtle.importKey('jwk', {
+        async native() {
+            const str = this.toString();
+            return await $mol_crypto_native.subtle.importKey('jwk', {
                 crv: "P-256",
                 ext: true,
                 key_ops: ['sign'],
                 kty: "EC",
-                x: serial.slice(0, 43),
-                y: serial.slice(43, 86),
-                d: serial.slice(86, 129),
-            }, algorithm, true, ['sign']));
+                x: str.slice(0, 43),
+                y: str.slice(43, 86),
+                d: str.slice(86, 129),
+            }, algorithm, true, ['sign']);
         }
-        async serial() {
-            const { x, y, d } = await $mol_crypto_native.subtle.exportKey('jwk', this.native);
-            return x + y + d;
-        }
-        async toArray() {
-            const { x, y, d } = await $mol_crypto_native.subtle.exportKey('jwk', this.native);
-            return new Uint8Array([
-                ...$mol_base64_url_decode(x),
-                ...$mol_base64_url_decode(y),
-                ...$mol_base64_url_decode(d),
-            ]);
+        public() {
+            return new $mol_crypto_key_public(this.buffer, this.byteOffset, this.byteOffset + 64);
         }
         async sign(data) {
-            return await $mol_crypto_native.subtle.sign(algorithm, this.native, data);
-        }
-        async public() {
-            return await $mol_crypto_auditor_public.from($mol_crypto_auditor_private_to_public(await this.serial()));
+            return await $mol_crypto_native.subtle.sign(algorithm, await this.native(), data);
         }
     }
-    $.$mol_crypto_auditor_private = $mol_crypto_auditor_private;
-    $.$mol_crypto_auditor_sign_size = 64;
-    function $mol_crypto_auditor_private_to_public(serial) {
-        return serial.slice(0, 86);
-    }
-    $.$mol_crypto_auditor_private_to_public = $mol_crypto_auditor_private_to_public;
+    __decorate([
+        $mol_memo.method
+    ], $mol_crypto_key_private.prototype, "native", null);
+    __decorate([
+        $mol_memo.method
+    ], $mol_crypto_key_private.prototype, "public", null);
+    $.$mol_crypto_key_private = $mol_crypto_key_private;
 })($ || ($ = {}));
-//mol/crypto/auditor/auditor.ts
+//mol/crypto/key/key.ts
 ;
 "use strict";
 var $;