smoothly 1.0.0-alpha.99 → 1.0.0

package/dist/esm/Data-77d2bdbe.js

@@ -1,803 +0,0 @@
-class TextEncoder {
-    constructor() {
-        this.encoding = "utf-8";
-    }
-    encode(data) {
-        return Uint8Array.from(unescape(encodeURIComponent(data)).split(""), c => c.charCodeAt(0));
-    }
-}
-
-const tables = {
-    standard: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-    url: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
-};
-function encode(value, standard = "standard", padding = "") {
-    if (typeof value == "string")
-        value = new TextEncoder().encode(value);
-    const table = tables[standard];
-    const result = [];
-    for (let c = 0; c < value.length; c += 3) {
-        const c0 = value[c];
-        const c1 = c + 1 < value.length ? value[c + 1] : 0;
-        const c2 = c + 2 < value.length ? value[c + 2] : 0;
-        result.push(table[c0 >>> 2]);
-        result.push(table[((c0 & 3) << 4) | (c1 >>> 4)]);
-        result.push(table[((c1 & 15) << 2) | (c2 >>> 6)]);
-        result.push(table[c2 & 63]);
-    }
-    const length = Math.ceil((value.length / 3) * 4);
-    return result.join("").substr(0, length) + padding.repeat(result.length - length);
-}
-function decode(value, standard = "standard") {
-    while (value.endsWith("=") && value.length > 0)
-        value = value.substr(0, value.length - 1);
-    const table = tables[standard];
-    const data = value.split("").map(c => table.indexOf(c));
-    const result = new Uint8Array(Math.floor((data.length / 4) * 3));
-    for (let c = 0; c < result.length; c += 3) {
-        const d0 = data.shift() || 0;
-        const d1 = data.shift() || 0;
-        const d2 = data.shift() || 0;
-        const d3 = data.shift() || 0;
-        result[c] = (d0 << 2) | (d1 >>> 4);
-        result[c + 1] = ((d1 & 15) << 4) | (d2 >>> 2);
-        result[c + 2] = ((d2 & 3) << 6) | d3;
-    }
-    return result;
-}
-function next(value, increment = 1, standard = "standard") {
-    const table = tables[standard];
-    const rest = value.length > 1 ? value.substring(0, value.length - 1) : increment > 0 ? "" : table[63];
-    const number = (value.length == 0 ? 0 : table.indexOf(value[value.length - 1])) + increment;
-    return ((number > 63 || number < 0 ? next(rest, Math.floor(number / 63), standard) : rest) + table[remainder(number, 64)]);
-}
-function remainder(left, right) {
-    return left >= 0 ? left % right : remainder(left + right, right);
-}
-
-const crypto = typeof window != "undefined"
-    ? window.crypto || window.msCrypto
-    : self.crypto || self.msCrypto;
-
-var Algorithms;
-(function (Algorithms) {
-    function create(create, current, ...secrets) {
-        const [first, ...remainder] = isStringArray(secrets)
-            ? secrets.map(part => Object.fromEntries(part.split(",").map(secret => secret.split(":", 2).map(item => item.trim()))))
-            : secrets;
-        const result = Object.assign({}, ...Object.entries(first)
-            .map(([name, secret]) => [
-            name,
-            [secret, ...remainder.map(part => part[name]).filter(part => part)],
-        ])
-            .map(([name, secrets]) => ({
-            get [name]() {
-                return Object.assign(create(secrets), { name });
-            },
-        })));
-        return { current: result[current], ...result };
-    }
-    Algorithms.create = create;
-})(Algorithms || (Algorithms = {}));
-function isStringArray(value) {
-    return Array.isArray(value) && value.length > 0 && typeof value[0] == "string";
-}
-
-var Encrypted;
-(function (Encrypted) {
-    function is(value) {
-        return (typeof value == "object" &&
-            (value.key == undefined || typeof value.key == "string") &&
-            typeof value.value == "string" &&
-            typeof value.salt == "string");
-    }
-    Encrypted.is = is;
-    function stringify(encrypted) {
-        encrypted.key = encrypted.key && encrypted.key.length != 4 ? encrypted.key.slice(-2) : encrypted.key;
-        return [encrypted.key, encrypted.salt, encrypted.value].join(".");
-    }
-    Encrypted.stringify = stringify;
-    function parse(encryptedString) {
-        const splitted = encryptedString.split(".");
-        const encrypted = { key: splitted[0], salt: splitted[1], value: splitted[2] };
-        return Encrypted.is(encrypted) ? encrypted : undefined;
-    }
-    Encrypted.parse = parse;
-})(Encrypted || (Encrypted = {}));
-
-var Identifier;
-(function (Identifier) {
-    function is(value, length) {
-        return (typeof value == "string" &&
-            (length == undefined || value.length == length) &&
-            Array.from(value).every(c => (c >= "0" && c <= "9") || (c >= "A" && c <= "Z") || (c >= "a" && c <= "z") || c == "-" || c == "_"));
-    }
-    Identifier.is = is;
-    function fromUint24(value) {
-        return fromHexadecimal(value.toString(16).padStart(6, "0"));
-    }
-    Identifier.fromUint24 = fromUint24;
-    function toUint24(identifier) {
-        return Number.parseInt(toHexadecimal(identifier, 6), 16);
-    }
-    Identifier.toUint24 = toUint24;
-    function fromUint48(value) {
-        return fromHexadecimal(value.toString(16).padStart(12, "0"));
-    }
-    Identifier.fromUint48 = fromUint48;
-    function toUint48(identifier) {
-        return Number.parseInt(toHexadecimal(identifier, 12), 16);
-    }
-    Identifier.toUint48 = toUint48;
-    function fromBinary(identifier) {
-        return encode(identifier, "url");
-    }
-    Identifier.fromBinary = fromBinary;
-    function toBinary(identifier) {
-        return decode(identifier, "url");
-    }
-    Identifier.toBinary = toBinary;
-    function generate(length) {
-        return fromBinary(crypto.getRandomValues(new Uint8Array((length / 4) * 3)));
-    }
-    Identifier.generate = generate;
-    function fromHexadecimal(identifier) {
-        if (identifier.length % 2 == 1)
-            identifier += "0";
-        const result = new Uint8Array(identifier.length / 2);
-        for (let index = 0; index < result.length; index++)
-            result[index] = Number.parseInt(identifier[index * 2], 16) * 16 + Number.parseInt(identifier[index * 2 + 1], 16);
-        return fromBinary(result);
-    }
-    Identifier.fromHexadecimal = fromHexadecimal;
-    function toHexadecimal(identifier, length) {
-        const data = decode(identifier, "url");
-        let result = [];
-        for (const d of data)
-            result.push(Math.floor(d / 16).toString(16), (d % 16).toString(16));
-        if (length)
-            result = result.slice(0, length);
-        return result.join("");
-    }
-    Identifier.toHexadecimal = toHexadecimal;
-    function min(length) {
-        return "".padStart(length, "A");
-    }
-    Identifier.min = min;
-    function max(length) {
-        return "".padStart(length, "_");
-    }
-    Identifier.max = max;
-    function next$1(identifier, increment = 1) {
-        const result = next(identifier, increment, "url");
-        return result.length == identifier.length ? result : result.substring(result.length - identifier.length);
-    }
-    Identifier.next = next$1;
-    function previous(identifier, decrement = 1) {
-        return next$1(identifier, -decrement);
-    }
-    Identifier.previous = previous;
-    Identifier.length = [
-        4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112,
-        116, 120, 124, 128,
-    ];
-    (function (Length) {
-        function is(value) {
-            return typeof value == "number" && value >= 4 && value <= 128 && (value & 252) == value;
-        }
-        Length.is = is;
-    })(Identifier.Length || (Identifier.Length = {}));
-})(Identifier || (Identifier = {}));
-
-var Password;
-(function (Password) {
-    function is(value) {
-        return (typeof value == "string" ||
-            (typeof value == "object" && typeof value.hash == "string" && typeof value.salt == "string"));
-    }
-    Password.is = is;
-    async function hash(algorithm, password, salt) {
-        if (!salt)
-            salt = encode(crypto.getRandomValues(new Uint8Array(64)));
-        return {
-            hash: await algorithm.sign(salt + password),
-            salt,
-        };
-    }
-    Password.hash = hash;
-    async function verify(algorithm, hash, password) {
-        return (await Password.hash(algorithm, password, hash.salt)).hash == hash.hash;
-    }
-    Password.verify = verify;
-    (function (Hashed) {
-        function is(value) {
-            return typeof value == "object" && typeof value.hash == "string" && typeof value.salt == "string";
-        }
-        Hashed.is = is;
-    })(Password.Hashed || (Password.Hashed = {}));
-})(Password || (Password = {}));
-
-var RandomValue;
-(function (RandomValue) {
-    function generate(array) {
-        return crypto.getRandomValues(array);
-    }
-    RandomValue.generate = generate;
-})(RandomValue || (RandomValue = {}));
-
-var Algorithm$1;
-(function (Algorithm) {
-    function is(value) {
-        return value == "HMAC" || value == "RSA" || value == "ECDSA" || value == "RSA-PSS";
-    }
-    Algorithm.is = is;
-})(Algorithm$1 || (Algorithm$1 = {}));
-
-class Base {
-    async sign(data) {
-        return typeof data == "string"
-            ? encode(await this.signBinary(new TextEncoder().encode(data)), "url")
-            : this.signBinary(data);
-    }
-    verify(data, signature) {
-        if (typeof signature == "string")
-            signature = decode(signature, "url");
-        return typeof data == "string"
-            ? this.verifyBinary(new TextEncoder().encode(data), signature)
-            : this.verifyBinary(data, signature);
-    }
-}
-
-class ECDSA extends Base {
-    constructor(hash, publicKey, privateKey) {
-        super();
-        this.hash = hash;
-        if (publicKey) {
-            if (typeof publicKey == "string")
-                publicKey = decode(publicKey);
-            this.publicKey = crypto.subtle.importKey("spki", publicKey, { name: "ECDSA", namedCurve: hash.replace("SHA", "P") == "P-512" ? "P-521" : hash.replace("SHA", "P") }, false, ["verify"]);
-        }
-        if (privateKey) {
-            if (typeof privateKey == "string")
-                privateKey = decode(privateKey);
-            this.privateKey = crypto.subtle.importKey("pkcs8", privateKey, { name: "ECDSA", namedCurve: hash.replace("SHA", "P") == "P-512" ? "P-521" : hash.replace("SHA", "P") }, true, ["sign", "verify"]);
-        }
-    }
-    async signBinary(data) {
-        return new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: { name: this.hash } }, await this.privateKey, data));
-    }
-    async verifyBinary(data, signature) {
-        return crypto.subtle.verify({ name: "ECDSA", hash: { name: this.hash } }, await this.publicKey, signature, data);
-    }
-}
-
-var Hash;
-(function (Hash) {
-    function is(value) {
-        return value == "SHA-1" || value == "SHA-256" || value == "SHA-384" || value == "SHA-512";
-    }
-    Hash.is = is;
-})(Hash || (Hash = {}));
-
-class Symmetric$1 extends Base {
-    async verifyBinary(data, signature) {
-        return encode(await this.signBinary(data), "url") == encode(signature, "url");
-    }
-}
-
-class HMAC extends Symmetric$1 {
-    constructor(hash, key) {
-        super();
-        this.hash = hash;
-        if (typeof key == "string")
-            key = decode(key, "url");
-        this.key = crypto.subtle.importKey("raw", key, { name: "HMAC", hash: { name: hash } }, false, ["sign", "verify"]);
-    }
-    async signBinary(data) {
-        return new Uint8Array(await crypto.subtle.sign("HMAC", await this.key, data));
-    }
-}
-
-class None extends Symmetric$1 {
-    signBinary(_) {
-        return Promise.resolve(new Uint8Array(0));
-    }
-}
-
-class Rsa extends Base {
-    constructor(variant, publicKey, privateKey) {
-        super();
-        this.variant = variant;
-        this.publicKey = publicKey;
-        this.privateKey = privateKey;
-    }
-    get parameters() {
-        return getParameters(this.variant);
-    }
-    async signBinary(data) {
-        return this.privateKey
-            ? new Uint8Array(await crypto.subtle.sign(this.parameters, await this.privateKey, data))
-            : new Uint8Array(0);
-    }
-    async verifyBinary(data, signature) {
-        return !!this.publicKey && crypto.subtle.verify(this.parameters, await this.publicKey, signature, data);
-    }
-    async export(type, format = "base64") {
-        const key = await (type == "private" ? this.privateKey : this.publicKey);
-        let result;
-        if (key)
-            switch (format) {
-                case "jwk":
-                    result = await crypto.subtle.exportKey("jwk", key);
-                    break;
-                case "buffer":
-                    result = await crypto.subtle.exportKey(type == "private" ? "pkcs8" : "spki", key);
-                    break;
-                case "base64":
-                    {
-                        const data = await this.export(type, "buffer");
-                        result = data && encode(new Uint8Array(data), "standard", "=");
-                    }
-                    break;
-                case "pem":
-                    {
-                        const data = await this.export(type, "base64");
-                        result =
-                            data &&
-                                [
-                                    `-----BEGIN ${type.toUpperCase()} KEY-----`,
-                                    ...slice(data, 64),
-                                    `-----END ${type.toUpperCase()} KEY-----`,
-                                ].join("\n");
-                    }
-                    break;
-            }
-        return result;
-    }
-    static import(variant, hash, publicKey, privateKey) {
-        return new Rsa(variant, Rsa.importHelper(variant, hash, "public", publicKey), Rsa.importHelper(variant, hash, "private", privateKey));
-    }
-    static importHelper(variant, hash, type, key) {
-        if (typeof key == "string")
-            key = decode(key);
-        return (key &&
-            crypto.subtle.importKey(type == "private" ? "pkcs8" : "spki", key, { name: getParameters(variant).name, hash: { name: hash } }, true, [type == "private" ? "sign" : "verify"]));
-    }
-    static generate(variant, hash, length) {
-        const keyPair = crypto.subtle.generateKey({
-            name: getParameters(variant).name,
-            modulusLength: length,
-            publicExponent: new Uint8Array([1, 0, 1]),
-            hash,
-        }, true, ["sign", "verify"]);
-        return new Rsa(variant, keyPair.then(value => value.publicKey), keyPair.then(value => value.privateKey));
-    }
-}
-function* slice(data, length) {
-    let start = 0;
-    while (start < data.length)
-        yield data.slice(start, (start = start + length));
-}
-function getParameters(variant) {
-    return variant == "PSS" ? { name: "RSA-PSS", saltLength: 128 } : { name: "RSASSA-PKCS1-v1_5" };
-}
-
-var Signer;
-(function (Signer) {
-    (function (Algorithm) {
-        Algorithm.is = Algorithm$1.is;
-    })(Signer.Algorithm || (Signer.Algorithm = {}));
-    (function (Hash$1) {
-        Hash$1.is = Hash.is;
-    })(Signer.Hash || (Signer.Hash = {}));
-    function generate(algorithm, hash, length) {
-        let result;
-        switch (algorithm) {
-            case "RSA":
-                result = Rsa.generate("SSA", hash, length);
-                break;
-            case "RSA-PSS":
-                result = Rsa.generate("PSS", hash, length);
-                break;
-        }
-        return result;
-    }
-    Signer.generate = generate;
-    function create(algorithm, hash, ...keys) {
-        let result;
-        if (hash != undefined)
-            switch (algorithm) {
-                case "HMAC":
-                    result = new HMAC(hash, keys[0]);
-                    break;
-                case "RSA":
-                    result = Rsa.import("SSA", hash, keys[0], keys[1]);
-                    break;
-                case "RSA-PSS":
-                    result = Rsa.import("PSS", hash, keys[0], keys[1]);
-                    break;
-                case "ECDSA":
-                    result = new ECDSA(hash, keys[0], keys[1]);
-                    break;
-            }
-        else if (algorithm == "None")
-            result = new None();
-        return result;
-    }
-    Signer.create = create;
-})(Signer || (Signer = {}));
-
-if (!Uint8Array.__proto__.from) {
-    (() => {
-        Uint8Array.__proto__.from = function (object, theFunction, thisObject) {
-            const typedArrayClass = Uint8Array.__proto__;
-            if (typeof this !== "function") {
-                throw new TypeError("# is not a constructor");
-            }
-            if (this.__proto__ !== typedArrayClass) {
-                throw new TypeError("this is not a typed array.");
-            }
-            theFunction = theFunction || (element => element);
-            if (typeof theFunction !== "function") {
-                throw new TypeError("specified argument is not a function");
-            }
-            object = Object(object);
-            if (!object.length) {
-                return new this(0);
-            }
-            let copyData = [];
-            for (const data of copyData) {
-                copyData.push(data);
-            }
-            copyData = copyData.map(theFunction, thisObject);
-            const typedArray = new this(copyData.length);
-            for (let i = 0; i < typedArray.length; i++) {
-                typedArray[i] = copyData[i];
-            }
-            return typedArray;
-        };
-    })();
-}
-
-var Converter;
-(function (Converter) {
-    function is(value) {
-        return (typeof value == "object" &&
-            Object.values(value).every(v => v &&
-                typeof v == "object" &&
-                "forward" in v &&
-                typeof v.forward == "function" &&
-                "backward" in v &&
-                typeof v.backward == "function"));
-    }
-    Converter.is = is;
-})(Converter || (Converter = {}));
-
-var Crypto;
-(function (Crypto) {
-    function is(value) {
-        return Array.isArray(value) && value.every(v => typeof v == "string");
-    }
-    Crypto.is = is;
-})(Crypto || (Crypto = {}));
-
-var Renamer;
-(function (Renamer) {
-    function is(value) {
-        return typeof value == "object" && Object.entries(value).every(thing => typeof thing[1] == "string");
-    }
-    Renamer.is = is;
-})(Renamer || (Renamer = {}));
-
-var Creatable;
-(function (Creatable) {
-    function is(value) {
-        return Crypto.is(value) || Converter.is(value) || Renamer.is(value);
-    }
-    Creatable.is = is;
-    (function (Converter$1) {
-        Converter$1.is = Converter.is;
-    })(Creatable.Converter || (Creatable.Converter = {}));
-    (function (Crypto$1) {
-        Crypto$1.is = Crypto.is;
-    })(Creatable.Crypto || (Creatable.Crypto = {}));
-    (function (Renamer$1) {
-        Renamer$1.is = Renamer.is;
-    })(Creatable.Renamer || (Creatable.Renamer = {}));
-})(Creatable || (Creatable = {}));
-
-var Transformer;
-(function (Transformer) {
-    function is(value) {
-        return typeof value == "object" && typeof value.apply == "function" && typeof value.reverse == "function";
-    }
-    Transformer.is = is;
-    function create(transformer) {
-        return {
-            apply: transformer.apply ? transformer.apply : (v) => v,
-            reverse: transformer.reverse ? transformer.reverse : (v) => v,
-        };
-    }
-    Transformer.create = create;
-})(Transformer || (Transformer = {}));
-
-var Asymmetric;
-(function (Asymmetric) {
-    function is(value) {
-        return (value == "RS256" ||
-            value == "RS384" ||
-            value == "RS512" ||
-            value == "ES256" ||
-            value == "ES384" ||
-            value == "ES512" ||
-            value == "PS256" ||
-            value == "PS384" ||
-            value == "PS512");
-    }
-    Asymmetric.is = is;
-})(Asymmetric || (Asymmetric = {}));
-
-var Symmetric;
-(function (Symmetric) {
-    function is(value) {
-        return value == "HS256" || value == "HS384" || value == "HS512";
-    }
-    Symmetric.is = is;
-})(Symmetric || (Symmetric = {}));
-
-var Name;
-(function (Name) {
-    function is(value) {
-        return value == "none" || Symmetric.is(value) || Asymmetric.is(value);
-    }
-    Name.is = is;
-    (function (Symmetric$1) {
-        Symmetric$1.is = Symmetric.is;
-    })(Name.Symmetric || (Name.Symmetric = {}));
-    (function (Asymmetric$1) {
-        Asymmetric$1.is = Asymmetric.is;
-    })(Name.Asymmetric || (Name.Asymmetric = {}));
-})(Name || (Name = {}));
-
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-class Algorithm {
-    constructor(name, signer) {
-        this.name = name;
-        this.signer = signer;
-    }
-    sign(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return typeof data == "string" ? this.signer.sign(data) : this.signer.sign(data);
-        });
-    }
-    verify(data, signature) {
-        return this.signer.verify(data, signature);
-    }
-    static create(name, ...keys) {
-        let result;
-        switch (name) {
-            case "ES256":
-                result = Signer.create("ECDSA", "SHA-256", keys[0], keys[1]);
-                break;
-            case "ES384":
-                result = Signer.create("ECDSA", "SHA-384", keys[0], keys[1]);
-                break;
-            case "ES512":
-                result = Signer.create("ECDSA", "SHA-512", keys[0], keys[1]);
-                break;
-            case "PS256":
-                result = Signer.create("RSA-PSS", "SHA-256", keys[0], keys[1]);
-                break;
-            case "PS384":
-                result = Signer.create("RSA-PSS", "SHA-384", keys[0], keys[1]);
-                break;
-            case "PS512":
-                result = Signer.create("RSA-PSS", "SHA-512", keys[0], keys[1]);
-                break;
-            case "HS256":
-                result = Signer.create("HMAC", "SHA-256", keys[0]);
-                break;
-            case "HS384":
-                result = Signer.create("HMAC", "SHA-384", keys[0]);
-                break;
-            case "HS512":
-                result = Signer.create("HMAC", "SHA-512", keys[0]);
-                break;
-            case "RS256":
-                result = Signer.create("RSA", "SHA-256", keys[0], keys[1]);
-                break;
-            case "RS384":
-                result = Signer.create("RSA", "SHA-384", keys[0], keys[1]);
-                break;
-            case "RS512":
-                result = Signer.create("RSA", "SHA-512", keys[0], keys[1]);
-                break;
-            case "none":
-                result = Signer.create("None");
-                break;
-        }
-        return result && new Algorithm(name, result);
-    }
-    static none() {
-        return Algorithm.create("none");
-    }
-    static HS256(key) {
-        return Algorithm.create("HS256", key);
-    }
-    static HS384(key) {
-        return Algorithm.create("HS384", key);
-    }
-    static HS512(key) {
-        return Algorithm.create("HS512", key);
-    }
-    static RS256(publicKey, privateKey) {
-        return Algorithm.create("RS256", publicKey, privateKey);
-    }
-    static RS384(publicKey, privateKey) {
-        return Algorithm.create("RS384", publicKey, privateKey);
-    }
-    static RS512(publicKey, privateKey) {
-        return Algorithm.create("RS512", publicKey, privateKey);
-    }
-    static ES256(publicKey, privateKey) {
-        return Algorithm.create("ES256", publicKey, privateKey);
-    }
-    static ES384(publicKey, privateKey) {
-        return Algorithm.create("ES384", publicKey, privateKey);
-    }
-    static ES512(publicKey, privateKey) {
-        return Algorithm.create("ES512", publicKey, privateKey);
-    }
-    static PS256(publicKey, privateKey) {
-        return Algorithm.create("PS256", publicKey, privateKey);
-    }
-    static PS384(publicKey, privateKey) {
-        return Algorithm.create("PS384", publicKey, privateKey);
-    }
-    static PS512(publicKey, privateKey) {
-        return Algorithm.create("PS512", publicKey, privateKey);
-    }
-}
-(function (Algorithm) {
-    (function (Name$1) {
-        Name$1.is = Name.is;
-        (function (Symmetric) {
-            Symmetric.is = Name.Symmetric.is;
-        })(Name$1.Symmetric || (Name$1.Symmetric = {}));
-        (function (Asymmetric) {
-            Asymmetric.is = Name.Asymmetric.is;
-        })(Name$1.Asymmetric || (Name$1.Asymmetric = {}));
-    })(Algorithm.Name || (Algorithm.Name = {}));
-})(Algorithm || (Algorithm = {}));
-
-var Token;
-(function (Token) {
-    function is(value) {
-        return typeof value == "string" && /^[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*$/.test(value);
-    }
-    Token.is = is;
-})(Token || (Token = {}));
-
-class Message {
-  static is(value) {
-    return typeof value == "object" && typeof value.destination == "string" && value.content != undefined;
-  }
-  static send(message, content, context) {
-    if (Message.is(message) && context == undefined) {
-      context = content;
-      if (!context)
-        context = window;
-      const destination = message.destination.split("#", 2);
-      message = { destination: destination[1], content: message.content };
-      context.postMessage(message, destination[0]);
-    }
-    else if (typeof context != "string") {
-      if (!context)
-        context = window;
-      if (typeof message == "string")
-        Message.send({ destination: message, content }, context);
-    }
-  }
-  static listen(origin, handle, context) {
-    const splitted = origin.split("#", 2);
-    let destination = "";
-    if (splitted.length == 2) {
-      origin = splitted[0];
-      destination = splitted[1];
-    }
-    (context || window).addEventListener("message", (e) => {
-      const message = e.data;
-      if (Message.is(message) &&
-        (origin == "*" || e.origin == origin) &&
-        (destination == "" || message.destination == destination))
-        handle(message.destination, message.content);
-    });
-  }
-}
-
-class Trigger {
-  static is(value) {
-    return typeof value == "object" && typeof value.name == "string";
-  }
-}
-
-var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Listenable_listeners;
-class Listenable {
-  constructor() {
-    _Listenable_listeners.set(this, {});
-  }
-  listen(property, listener) {
-    var _a, _b;
-    (_b = (_a = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _a === void 0 ? void 0 : _a.push(listener)) !== null && _b !== void 0 ? _b : (__classPrivateFieldGet(this, _Listenable_listeners, "f")[property] = [listener]);
-    listener(this[property]);
-  }
-  unlisten(property, listener) {
-    var _a, _b;
-    const index = (_a = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _a === void 0 ? void 0 : _a.indexOf(listener);
-    index != undefined && index >= 0 && ((_b = __classPrivateFieldGet(this, _Listenable_listeners, "f")[property]) === null || _b === void 0 ? void 0 : _b.splice(index, 1));
-  }
-  static load(backend) {
-    const result = backend.listenable;
-    return Object.defineProperties(result, getProperties(backend));
-    function getProperties(backend) {
-      return Object.fromEntries(Object.entries(Object.assign(Object.assign({}, Object.getOwnPropertyDescriptors(backend)), Object.getOwnPropertyDescriptors(Object.getPrototypeOf(backend)))).map(([name, descriptor]) => [
-        name,
-        typeof descriptor.value == "function"
-          ? {
-            get() {
-              return backend[name].bind(backend);
-            },
-          }
-          : descriptor.writable || descriptor.set
-            ? {
-              get() {
-                return backend[name];
-              },
-              set(value) {
-                var _a;
-                backend[name] = value;
-                (_a = __classPrivateFieldGet(result, _Listenable_listeners, "f")[name]) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(value));
-              },
-            }
-            : {
-              get() {
-                return backend[name];
-              },
-            },
-      ]));
-    }
-  }
-}
-_Listenable_listeners = new WeakMap();
-
-var Data;
-(function (Data) {
-  function set(data, [head, ...tail], value) {
-    const current = data[head !== null && head !== void 0 ? head : ""];
-    return Object.assign(Object.assign({}, data), { [head !== null && head !== void 0 ? head : ""]: !tail.length
-        ? value
-        : set(typeof current == "object" && !(current instanceof Blob) ? current : {}, tail, value) });
-  }
-  Data.set = set;
-  function deepen(data) {
-    return Object.entries(data).reduce((result, [name, value]) => set(result, name.split("."), value), {});
-  }
-  Data.deepen = deepen;
-})(Data || (Data = {}));
-
-export { Data as D, Identifier as I, Listenable as L, Message as M, Trigger as T };
-
-//# sourceMappingURL=Data-77d2bdbe.js.map