@dashkite/vega-client 0.1.0

package/build/browser/src/utils.js

@@ -0,0 +1,29 @@
+var Confidential, JSON64;
+import { confidential } from "panda-confidential";
+Confidential = confidential();
+JSON64 = {
+    nonce: async function() {
+        return Confidential.convert({
+            from: "bytes",
+            to: "base64"
+        }, await Confidential.randomBytes(4));
+    },
+    encode: function(value) {
+        return Confidential.convert({
+            from: "utf8",
+            to: "base64"
+        }, JSON.stringify(value));
+    },
+    decode: function(value) {
+        var converted;
+        converted = Confidential.convert({
+            from: "base64",
+            to: "utf8"
+        }, value);
+        return JSON.parse(converted);
+    }
+};
+export { JSON64 }; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiL0BkYXNoa2l0ZS92ZWdhLWNsaWVudC9zcmMvdXRpbHMuY29mZmVlIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLElBQUEsWUFBQSxFQUFBOztBQUFBLE9BQUE7RUFBUyxZQUFUO0NBQUEsTUFBQTs7QUFFQSxZQUFBLEdBQWUsWUFBQSxDQUFBOztBQUVmLE1BQUEsR0FFRTtFQUFBLEtBQUEsRUFBTyxNQUFBLFFBQUEsQ0FBQSxDQUFBO1dBQ0wsWUFBWSxDQUFDLE9BQWIsQ0FDRTtNQUFBLElBQUEsRUFBTSxPQUFOO01BQ0EsRUFBQSxFQUFJO0lBREosQ0FERixFQUdFLENBQUEsTUFBTSxZQUFZLENBQUMsV0FBYixDQUF5QixDQUF6QixDQUFOLENBSEY7RUFESyxDQUFQO0VBS0EsTUFBQSxFQUFRLFFBQUEsQ0FBQyxLQUFELENBQUE7V0FDTixZQUFZLENBQUMsT0FBYixDQUNFO01BQUEsSUFBQSxFQUFNLE1BQU47TUFDQSxFQUFBLEVBQUk7SUFESixDQURGLEVBR0UsSUFBSSxDQUFDLFNBQUwsQ0FBZSxLQUFmLENBSEY7RUFETSxDQUxSO0VBV0EsTUFBQSxFQUFRLFFBQUEsQ0FBQyxLQUFELENBQUE7QUFDVixRQUFBO0lBQUksU0FBQSxHQUFZLFlBQVksQ0FBQyxPQUFiLENBQ1Y7TUFBQSxJQUFBLEVBQU0sUUFBTjtNQUNBLEVBQUEsRUFBSTtJQURKLENBRFUsRUFHVixLQUhVO1dBSVosSUFBSSxDQUFDLEtBQUwsQ0FBVyxTQUFYO0VBTE07QUFYUjs7QUFrQkYsT0FBQTtFQUFTLE1BQVQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb25maWRlbnRpYWwgfSBmcm9tIFwicGFuZGEtY29uZmlkZW50aWFsXCJcblxuQ29uZmlkZW50aWFsID0gY29uZmlkZW50aWFsKClcblxuSlNPTjY0ID1cblxuICBub25jZTogLT5cbiAgICBDb25maWRlbnRpYWwuY29udmVydFxuICAgICAgZnJvbTogXCJieXRlc1wiXG4gICAgICB0bzogXCJiYXNlNjRcIlxuICAgICAgYXdhaXQgQ29uZmlkZW50aWFsLnJhbmRvbUJ5dGVzIDRcbiAgZW5jb2RlOiAodmFsdWUpIC0+XG4gICAgQ29uZmlkZW50aWFsLmNvbnZlcnRcbiAgICAgIGZyb206IFwidXRmOFwiXG4gICAgICB0bzogXCJiYXNlNjRcIlxuICAgICAgSlNPTi5zdHJpbmdpZnkgdmFsdWVcbiAgXG4gIGRlY29kZTogKHZhbHVlKSAtPlxuICAgIGNvbnZlcnRlZCA9IENvbmZpZGVudGlhbC5jb252ZXJ0XG4gICAgICBmcm9tOiBcImJhc2U2NFwiXG4gICAgICB0bzogXCJ1dGY4XCJcbiAgICAgIHZhbHVlXG4gICAgSlNPTi5wYXJzZSBjb252ZXJ0ZWRcblxuZXhwb3J0IHsgSlNPTjY0IH0iXX0=
+ //# sourceURL=/@dashkite/vega-client/src/utils.coffee
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlcyI6WyIvQGRhc2hraXRlL3ZlZ2EtY2xpZW50L3NyYy91dGlscy5jb2ZmZWUiXSwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvbmZpZGVudGlhbCB9IGZyb20gXCJwYW5kYS1jb25maWRlbnRpYWxcIlxuXG5Db25maWRlbnRpYWwgPSBjb25maWRlbnRpYWwoKVxuXG5KU09ONjQgPVxuXG4gIG5vbmNlOiAtPlxuICAgIENvbmZpZGVudGlhbC5jb252ZXJ0XG4gICAgICBmcm9tOiBcImJ5dGVzXCJcbiAgICAgIHRvOiBcImJhc2U2NFwiXG4gICAgICBhd2FpdCBDb25maWRlbnRpYWwucmFuZG9tQnl0ZXMgNFxuICBlbmNvZGU6ICh2YWx1ZSkgLT5cbiAgICBDb25maWRlbnRpYWwuY29udmVydFxuICAgICAgZnJvbTogXCJ1dGY4XCJcbiAgICAgIHRvOiBcImJhc2U2NFwiXG4gICAgICBKU09OLnN0cmluZ2lmeSB2YWx1ZVxuICBcbiAgZGVjb2RlOiAodmFsdWUpIC0+XG4gICAgY29udmVydGVkID0gQ29uZmlkZW50aWFsLmNvbnZlcnRcbiAgICAgIGZyb206IFwiYmFzZTY0XCJcbiAgICAgIHRvOiBcInV0ZjhcIlxuICAgICAgdmFsdWVcbiAgICBKU09OLnBhcnNlIGNvbnZlcnRlZFxuXG5leHBvcnQgeyBKU09ONjQgfSJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFBLFlBQUEsRUFBQTtBQUFBLE9BQUEsRUFBUyxZQUFULFFBQUEscUJBQUE7QUFFQSxZQUFBLEdBQWUsWUFBQSxDQUFBO0FBRWYsTUFBQSxHQUVFO0lBQUEsS0FBQSxFQUFPLE1BQUEsUUFBQSxDQUFBLENBQUE7ZUFDTCxZQUFZLENBQUMsT0FBYixDQUNFO1lBQUEsSUFBQSxFQUFNLE9BQU47WUFDQSxFQUFBLEVBQUk7UUFESixDQURGLEVBR0UsTUFBTSxZQUFZLENBQUMsV0FBYixDQUF5QixDQUF6QixDQUFOLENBSEY7SUFESyxDQUFQO0lBS0EsTUFBQSxFQUFRLFFBQUEsQ0FBQyxLQUFELENBQUE7ZUFDTixZQUFZLENBQUMsT0FBYixDQUNFO1lBQUEsSUFBQSxFQUFNLE1BQU47WUFDQSxFQUFBLEVBQUk7UUFESixDQURGLEVBR0UsSUFBSSxDQUFDLFNBQUwsQ0FBZSxLQUFmLENBSEY7SUFETSxDQUxSO0lBV0EsTUFBQSxFQUFRLFFBQUEsQ0FBQyxLQUFELENBQUE7UUFDVixJQUFBO1FBQUksU0FBQSxHQUFZLFlBQVksQ0FBQyxPQUFiLENBQ1Y7WUFBQSxJQUFBLEVBQU0sUUFBTjtZQUNBLEVBQUEsRUFBSTtRQURKLENBRFUsRUFHVixLQUhVO2VBSVosSUFBSSxDQUFDLEtBQUwsQ0FBVyxTQUFYO0lBTE07QUFYUjtBQWtCRixPQUFBLEVBQVMsTUFBVCJ9

package/build/browser/src/vega-core/credentials.js

@@ -0,0 +1,111 @@
+var Credentials;
+import * as Time from "@dashkite/joy/time";
+import { Authorization, WWWAuthenticate } from "@dashkite/http-headers";
+import * as Client from "@dashkite/runes-client";
+import Profile from "@dashkite/profile";
+import { JSON64 } from "../utils";
+Credentials = {
+    store: function(header) {
+        var authorization, i, len, ref, results, value;
+        authorization = Authorization.parse(header);
+        switch(authorization.scheme){
+            case "credentials":
+                ref = JSON64.decode(authorization.token);
+                results = [];
+                for(i = 0, len = ref.length; i < len; i++){
+                    value = ref[i];
+                    results.push(Credentials.storeSingle(Authorization.parse(value)));
+                }
+                return results;
+                break;
+            case "rune":
+                return Credentials.storeSingle(authorization);
+            default:
+                throw new Error(`unable to store credentials with scheme ${scheme}`);
+        }
+    },
+    storeSingle: function({ scheme: scheme1, parameters } = {}) {
+        switch(scheme1){
+            case "rune":
+                return Client.store({
+                    rune: parameters.rune,
+                    nonce: parameters.nonce
+                });
+            default:
+                throw new Error(`unable to store credentials with scheme ${scheme1}`);
+        }
+    },
+    pull: async function(context) {
+        var header, location, response, status;
+        location = context.sublime.response.headers.get("location");
+        while(true){
+            response = await fetch(location);
+            if (response.status !== 200) {
+                throw new Error("received non 200 response from 401 location header");
+            }
+            ({ status } = await response.json());
+            if (status === "success") {
+                header = response.headers.get("credentials");
+                return Credentials.store(header);
+            } else {
+                await Time.sleep(1000); // wait one second
+            }
+        }
+    },
+    parse: function(header) {
+        var authorization, i, len, results, value, values;
+        authorization = Authorization.parse(header);
+        if (authorization.scheme === "credentials") {
+            values = JSON64.decode(authorization.token);
+            results = [];
+            for(i = 0, len = values.length; i < len; i++){
+                value = values[i];
+                results.push(Authorization.parse(value));
+            }
+            return results;
+        } else {
+            return [
+                authorization
+            ];
+        }
+    },
+    prune: function(context) {
+        var authorization, credentials, domain, i, identity, len, method, nonce, parameters, resource, results, rune, scheme1;
+        ({ authorization } = context.sublime.request.headers);
+        ({ domain, resource, method } = context.sublime.response.content);
+        ({ email: identity } = Profile.load());
+        Client.removeBound({
+            identity,
+            domain
+        });
+        credentials = Credentials.parse(authorization);
+        results = [];
+        for(i = 0, len = credentials.length; i < len; i++){
+            ({ scheme: scheme1, parameters } = credentials[i]);
+            if (!(scheme1 === "rune")) {
+                continue;
+            }
+            ({ rune, nonce } = parameters);
+            if (Client.hasGrant(rune, {
+                domain,
+                resource,
+                method
+            })) {
+                ({ email: identity } = Profile.load());
+                results.push(Client.remove({
+                    identity,
+                    domain,
+                    rune,
+                    nonce
+                }));
+            } else {
+                results.push(void 0);
+            }
+        }
+        return results;
+    }
+};
+export default Credentials; //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiL0BkYXNoa2l0ZS92ZWdhLWNsaWVudC9zcmMvdmVnYS1jb3JlL2NyZWRlbnRpYWxzLmNvZmZlZSJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFBOztBQUFBLE9BQU8sQ0FBQSxRQUFQLE1BQUE7O0FBQ0EsT0FBQTtFQUFTLGFBQVQ7RUFBd0IsZUFBeEI7Q0FBQSxNQUFBOztBQUNBLE9BQU8sQ0FBQSxVQUFQLE1BQUE7O0FBQ0EsT0FBTyxPQUFQLE1BQUE7O0FBQ0EsT0FBQTtFQUFTLE1BQVQ7Q0FBQSxNQUFBOztBQUdBLFdBQUEsR0FDRTtFQUFBLEtBQUEsRUFBTyxRQUFBLENBQUUsTUFBRixDQUFBO0FBQ1QsUUFBQSxhQUFBLEVBQUEsQ0FBQSxFQUFBLEdBQUEsRUFBQSxHQUFBLEVBQUEsT0FBQSxFQUFBO0lBQUksYUFBQSxHQUFnQixhQUFhLENBQUMsS0FBZCxDQUFvQixNQUFwQjtBQUNoQixZQUFPLGFBQWEsQ0FBQyxNQUFyQjtBQUFBLFdBQ08sYUFEUDtBQUVJO0FBQUE7UUFBQSxLQUFBLHFDQUFBOzt1QkFDRSxXQUFXLENBQUMsV0FBWixDQUF3QixhQUFhLENBQUMsS0FBZCxDQUFvQixLQUFwQixDQUF4QjtRQURGLENBQUE7O0FBREc7QUFEUCxXQUlPLE1BSlA7ZUFLSSxXQUFXLENBQUMsV0FBWixDQUF3QixhQUF4QjtBQUxKO1FBT0ksTUFBTSxJQUFJLEtBQUosQ0FBVSxDQUFBLHdDQUFBLENBQUEsQ0FBNEMsTUFBNUMsQ0FBQSxDQUFWO0FBUFY7RUFGSyxDQUFQO0VBV0EsV0FBQSxFQUFhLFFBQUEsQ0FBQyxDQUFFLE1BQUYsRUFBVSxVQUFWLElBQXlCLENBQUEsQ0FBMUIsQ0FBQTtBQUNYLFlBQU8sTUFBUDtBQUFBLFdBQ08sTUFEUDtlQUVJLE1BQU0sQ0FBQyxLQUFQLENBQ0U7VUFBQSxJQUFBLEVBQU0sVUFBVSxDQUFDLElBQWpCO1VBQ0EsS0FBQSxFQUFPLFVBQVUsQ0FBQztRQURsQixDQURGO0FBRko7UUFNSSxNQUFNLElBQUksS0FBSixDQUFVLENBQUEsd0NBQUEsQ0FBQSxDQUE0QyxNQUE1QyxDQUFBLENBQVY7QUFOVjtFQURXLENBWGI7RUFxQkEsSUFBQSxFQUFNLE1BQUEsUUFBQSxDQUFFLE9BQUYsQ0FBQTtBQUNSLFFBQUEsTUFBQSxFQUFBLFFBQUEsRUFBQSxRQUFBLEVBQUE7SUFBSSxRQUFBLEdBQVcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEdBQWpDLENBQXFDLFVBQXJDO0FBQ1gsV0FBQSxJQUFBO01BQ0UsUUFBQSxHQUFXLENBQUEsTUFBTSxLQUFBLENBQU0sUUFBTixDQUFOO01BQ1gsSUFBRyxRQUFRLENBQUMsTUFBVCxLQUFtQixHQUF0QjtRQUNFLE1BQU0sSUFBSSxLQUFKLENBQVUsb0RBQVYsRUFEUjs7TUFFQSxDQUFBLENBQUUsTUFBRixDQUFBLEdBQWEsQ0FBQSxNQUFNLFFBQVEsQ0FBQyxJQUFULENBQUEsQ0FBTixDQUFiO01BQ0EsSUFBRyxNQUFBLEtBQVUsU0FBYjtRQUNFLE1BQUEsR0FBUyxRQUFRLENBQUMsT0FBTyxDQUFDLEdBQWpCLENBQXFCLGFBQXJCO0FBQ1QsZUFBTyxXQUFXLENBQUMsS0FBWixDQUFrQixNQUFsQixFQUZUO09BQUEsTUFBQTtRQUlFLE1BQU0sSUFBSSxDQUFDLEtBQUwsQ0FBVyxJQUFYLEVBSlI7O0lBTEY7RUFGSSxDQXJCTjtFQWtDQSxLQUFBLEVBQU8sUUFBQSxDQUFFLE1BQUYsQ0FBQTtBQUNULFFBQUEsYUFBQSxFQUFBLENBQUEsRUFBQSxHQUFBLEVBQUEsT0FBQSxFQUFBLEtBQUEsRUFBQTtJQUFJLGFBQUEsR0FBZ0IsYUFBYSxDQUFDLEtBQWQsQ0FBb0IsTUFBcEI7SUFDaEIsSUFBRyxhQUFhLENBQUMsTUFBZCxLQUF3QixhQUEzQjtNQUNFLE1BQUEsR0FBUyxNQUFNLENBQUMsTUFBUCxDQUFjLGFBQWEsQ0FBQyxLQUE1QjtBQUNUO01BQUEsS0FBQSx3Q0FBQTs7cUJBQUEsYUFBYSxDQUFDLEtBQWQsQ0FBb0IsS0FBcEI7TUFBQSxDQUFBO3FCQUZGO0tBQUEsTUFBQTthQUlFLENBQUUsYUFBRixFQUpGOztFQUZLLENBbENQO0VBMENBLEtBQUEsRUFBTyxRQUFBLENBQUUsT0FBRixDQUFBO0FBQ1QsUUFBQSxhQUFBLEVBQUEsV0FBQSxFQUFBLE1BQUEsRUFBQSxDQUFBLEVBQUEsUUFBQSxFQUFBLEdBQUEsRUFBQSxNQUFBLEVBQUEsS0FBQSxFQUFBLFVBQUEsRUFBQSxRQUFBLEVBQUEsT0FBQSxFQUFBLElBQUEsRUFBQTtJQUFJLENBQUEsQ0FBRSxhQUFGLENBQUEsR0FBb0IsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBNUM7SUFDQSxDQUFBLENBQUUsTUFBRixFQUFVLFFBQVYsRUFBb0IsTUFBcEIsQ0FBQSxHQUErQixPQUFPLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxPQUF4RDtJQUNBLENBQUE7TUFBRSxLQUFBLEVBQU87SUFBVCxDQUFBLEdBQXlCLE9BQU8sQ0FBQyxNQUFqQztJQUNBLE1BQU0sQ0FBQyxXQUFQLENBQW1CLENBQUUsUUFBRixFQUFZLE1BQVosQ0FBbkI7SUFDQSxXQUFBLEdBQWMsV0FBVyxDQUFDLEtBQVosQ0FBa0IsYUFBbEI7QUFDZDtJQUFBLEtBQUEsNkNBQUE7T0FBSSxDQUFFLE1BQUYsRUFBVSxVQUFWO1lBQTJDLE1BQUEsS0FBVTs7O01BQ3ZELENBQUEsQ0FBRSxJQUFGLEVBQVEsS0FBUixDQUFBLEdBQWtCLFVBQWxCO01BQ0EsSUFBRyxNQUFNLENBQUMsUUFBUCxDQUFnQixJQUFoQixFQUFzQixDQUFFLE1BQUYsRUFBVSxRQUFWLEVBQW9CLE1BQXBCLENBQXRCLENBQUg7UUFDRSxDQUFBO1VBQUUsS0FBQSxFQUFPO1FBQVQsQ0FBQSxHQUF5QixPQUFPLENBQUMsTUFBakM7cUJBQ0EsTUFBTSxDQUFDLE1BQVAsQ0FBYyxDQUFFLFFBQUYsRUFBWSxNQUFaLEVBQW9CLElBQXBCLEVBQTBCLEtBQTFCLENBQWQsR0FGRjtPQUFBLE1BQUE7NkJBQUE7O0lBRkYsQ0FBQTs7RUFOSztBQTFDUDs7QUF1REYsT0FBQSxRQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgVGltZSBmcm9tIFwiQGRhc2hraXRlL2pveS90aW1lXCJcbmltcG9ydCB7IEF1dGhvcml6YXRpb24sIFdXV0F1dGhlbnRpY2F0ZSB9IGZyb20gXCJAZGFzaGtpdGUvaHR0cC1oZWFkZXJzXCJcbmltcG9ydCAqIGFzIENsaWVudCBmcm9tIFwiQGRhc2hraXRlL3J1bmVzLWNsaWVudFwiXG5pbXBvcnQgUHJvZmlsZSBmcm9tIFwiQGRhc2hraXRlL3Byb2ZpbGVcIlxuaW1wb3J0IHsgSlNPTjY0IH0gZnJvbSBcIi4uL3V0aWxzXCJcblxuXG5DcmVkZW50aWFscyA9XG4gIHN0b3JlOiAoIGhlYWRlciApIC0+XG4gICAgYXV0aG9yaXphdGlvbiA9IEF1dGhvcml6YXRpb24ucGFyc2UgaGVhZGVyXG4gICAgc3dpdGNoIGF1dGhvcml6YXRpb24uc2NoZW1lXG4gICAgICB3aGVuIFwiY3JlZGVudGlhbHNcIlxuICAgICAgICBmb3IgdmFsdWUgaW4gSlNPTjY0LmRlY29kZSBhdXRob3JpemF0aW9uLnRva2VuXG4gICAgICAgICAgQ3JlZGVudGlhbHMuc3RvcmVTaW5nbGUgQXV0aG9yaXphdGlvbi5wYXJzZSB2YWx1ZSBcbiAgICAgIHdoZW4gXCJydW5lXCJcbiAgICAgICAgQ3JlZGVudGlhbHMuc3RvcmVTaW5nbGUgYXV0aG9yaXphdGlvblxuICAgICAgZWxzZVxuICAgICAgICB0aHJvdyBuZXcgRXJyb3IgXCJ1bmFibGUgdG8gc3RvcmUgY3JlZGVudGlhbHMgd2l0aCBzY2hlbWUgI3sgc2NoZW1lIH1cIlxuXG4gIHN0b3JlU2luZ2xlOiAoeyBzY2hlbWUsIHBhcmFtZXRlcnMgfSA9IHt9KSAtPlxuICAgIHN3aXRjaCBzY2hlbWVcbiAgICAgIHdoZW4gXCJydW5lXCJcbiAgICAgICAgQ2xpZW50LnN0b3JlIFxuICAgICAgICAgIHJ1bmU6IHBhcmFtZXRlcnMucnVuZVxuICAgICAgICAgIG5vbmNlOiBwYXJhbWV0ZXJzLm5vbmNlXG4gICAgICBlbHNlXG4gICAgICAgIHRocm93IG5ldyBFcnJvciBcInVuYWJsZSB0byBzdG9yZSBjcmVkZW50aWFscyB3aXRoIHNjaGVtZSAjeyBzY2hlbWUgfVwiXG5cblxuICBwdWxsOiAoIGNvbnRleHQgKSAtPlxuICAgIGxvY2F0aW9uID0gY29udGV4dC5zdWJsaW1lLnJlc3BvbnNlLmhlYWRlcnMuZ2V0IFwibG9jYXRpb25cIlxuICAgIGxvb3BcbiAgICAgIHJlc3BvbnNlID0gYXdhaXQgZmV0Y2ggbG9jYXRpb25cbiAgICAgIGlmIHJlc3BvbnNlLnN0YXR1cyAhPSAyMDBcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yIFwicmVjZWl2ZWQgbm9uIDIwMCByZXNwb25zZSBmcm9tIDQwMSBsb2NhdGlvbiBoZWFkZXJcIlxuICAgICAgeyBzdGF0dXMgfSA9IGF3YWl0IHJlc3BvbnNlLmpzb24oKVxuICAgICAgaWYgc3RhdHVzID09IFwic3VjY2Vzc1wiXG4gICAgICAgIGhlYWRlciA9IHJlc3BvbnNlLmhlYWRlcnMuZ2V0IFwiY3JlZGVudGlhbHNcIlxuICAgICAgICByZXR1cm4gQ3JlZGVudGlhbHMuc3RvcmUgaGVhZGVyXG4gICAgICBlbHNlXG4gICAgICAgIGF3YWl0IFRpbWUuc2xlZXAgMTAwMCAjIHdhaXQgb25lIHNlY29uZFxuXG4gIHBhcnNlOiAoIGhlYWRlciApIC0+XG4gICAgYXV0aG9yaXphdGlvbiA9IEF1dGhvcml6YXRpb24ucGFyc2UgaGVhZGVyXG4gICAgaWYgYXV0aG9yaXphdGlvbi5zY2hlbWUgPT0gXCJjcmVkZW50aWFsc1wiXG4gICAgICB2YWx1ZXMgPSBKU09ONjQuZGVjb2RlIGF1dGhvcml6YXRpb24udG9rZW5cbiAgICAgIEF1dGhvcml6YXRpb24ucGFyc2UgdmFsdWUgZm9yIHZhbHVlIGluIHZhbHVlc1xuICAgIGVsc2VcbiAgICAgIFsgYXV0aG9yaXphdGlvbiBdXG5cbiAgcHJ1bmU6ICggY29udGV4dCApIC0+XG4gICAgeyBhdXRob3JpemF0aW9uIH0gPSBjb250ZXh0LnN1YmxpbWUucmVxdWVzdC5oZWFkZXJzXG4gICAgeyBkb21haW4sIHJlc291cmNlLCBtZXRob2QgfSA9IGNvbnRleHQuc3VibGltZS5yZXNwb25zZS5jb250ZW50XG4gICAgeyBlbWFpbDogaWRlbnRpdHkgfSA9IGRvIFByb2ZpbGUubG9hZFxuICAgIENsaWVudC5yZW1vdmVCb3VuZCB7IGlkZW50aXR5LCBkb21haW4gfVxuICAgIGNyZWRlbnRpYWxzID0gQ3JlZGVudGlhbHMucGFyc2UgYXV0aG9yaXphdGlvblxuICAgIGZvciB7IHNjaGVtZSwgcGFyYW1ldGVycyB9IGluIGNyZWRlbnRpYWxzIHdoZW4gc2NoZW1lID09IFwicnVuZVwiXG4gICAgICB7IHJ1bmUsIG5vbmNlIH0gPSBwYXJhbWV0ZXJzXG4gICAgICBpZiBDbGllbnQuaGFzR3JhbnQgcnVuZSwgeyBkb21haW4sIHJlc291cmNlLCBtZXRob2QgfVxuICAgICAgICB7IGVtYWlsOiBpZGVudGl0eSB9ID0gZG8gUHJvZmlsZS5sb2FkXG4gICAgICAgIENsaWVudC5yZW1vdmUgeyBpZGVudGl0eSwgZG9tYWluLCBydW5lLCBub25jZSB9XG4gICAgXG5cbmV4cG9ydCBkZWZhdWx0IENyZWRlbnRpYWxzIl19
+ //# sourceURL=/@dashkite/vega-client/src/vega-core/credentials.coffee
+
+//# sourceMappingURL=data:application/json;base64,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

package/build/browser/src/vega-core/index.js

@@ -0,0 +1,130 @@
+var Core, Run, When, machine, request, indexOf = [].indexOf;
+import * as Value from "@dashkite/joy/value";
+import { Machine, Async, $end } from "@dashkite/talos";
+import { Authorization, WWWAuthenticate } from "@dashkite/http-headers";
+import HTTP from "../vega-sky";
+import Credentials from "./credentials";
+import Validate from "./validate";
+When = {
+    canRetry: function(talos) {
+        var directives, header, headers, status;
+        ({ status, headers } = talos.context.sublime.response);
+        if (status !== 401) {
+            return false;
+        }
+        if ((header = headers.get("www-authenticate")) == null) {
+            return false;
+        }
+        directives = WWWAuthenticate.parse(header);
+        directives = directives.map(function({ scheme }) {
+            return scheme;
+        });
+        return indexOf.call(directives, "rune") >= 0;
+    },
+    hasCredentials: function(talos) {
+        var response;
+        ({ response } = talos.context.sublime);
+        return response.headers.get("credentials") != null;
+    },
+    hasLocation: function(talos) {
+        var headers;
+        ({ headers } = talos.context.sublime.response);
+        return headers.get("location") != null;
+    },
+    canPrune: function(talos) {
+        var ref, ref1, ref2, request, response;
+        ({ request, response } = talos.context.sublime);
+        if (request.headers.authorization == null) {
+            return false;
+        }
+        if (response.contentCategory !== "json") {
+            return false;
+        }
+        if (((ref = response.content) != null ? ref.domain : void 0) == null) {
+            return false;
+        }
+        if (((ref1 = response.content) != null ? ref1.resource : void 0) == null) {
+            return false;
+        }
+        if (((ref2 = response.content) != null ? ref2.method : void 0) == null) {
+            return false;
+        }
+        return true;
+    }
+};
+Run = {
+    attempt: async function*(talos) {
+        var current, ref;
+        ref = HTTP.request(Value.clone(talos.context.input));
+        for await (current of ref){
+            yield current;
+        }
+        if (current.failure) {
+            throw current.error;
+        }
+        return talos.context.sublime = current.context;
+    },
+    storeCredentials: function(talos) {
+        var header;
+        header = talos.context.sublime.response.headers.get("credentials");
+        return Credentials.store(header);
+    },
+    pullCredentials: async function(talos) {
+        await Credentials.pull(talos.context);
+        return delete talos.context.input.authorization; // remove email auth literal
+    },
+    pruneCredentials: async function(talos) {
+        return await Credentials.prune(talos.context);
+    },
+    validate: async function(talos) {
+        return await Validate.response(talos.context);
+    }
+};
+machine = Machine.make("vega-client: core", {
+    start: "attempt",
+    attempt: {
+        run: Run.attempt,
+        move: "authorization"
+    },
+    authorization: {
+        retry: When.canRetry,
+        credentials: {
+            when: When.hasCredentials,
+            run: Run.storeCredentials,
+            move: "validate"
+        },
+        default: "validate"
+    },
+    retry: {
+        pullCredentials: {
+            priority: 1,
+            when: When.hasLocation,
+            run: Run.pullCredentials,
+            move: "attempt"
+        },
+        pruneCredentials: {
+            priority: 2,
+            when: When.canPrune,
+            run: Run.pruneCredentials,
+            move: "attempt"
+        },
+        default: "validate"
+    },
+    validate: {
+        run: Run.validate,
+        move: $end
+    }
+});
+request = function(context) {
+    return Async.start(machine, {
+        input: context
+    });
+};
+Core = {
+    request
+};
+export default Core;
+export { request }; //# sourceMappingURL=data:application/json;base64,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
+ //# sourceURL=/@dashkite/vega-client/src/vega-core/index.coffee
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"","sources":["/@dashkite/vega-client/src/vega-core/index.coffee"],"sourceRoot":"","sourcesContent":["import * as Value from \"@dashkite/joy/value\"\nimport { Machine, Async, $end } from \"@dashkite/talos\"\nimport { Authorization, WWWAuthenticate } from \"@dashkite/http-headers\"\nimport HTTP from \"../vega-sky\"\nimport Credentials from \"./credentials\"\nimport Validate from \"./validate\"\n\n\nWhen =\n  canRetry: ( talos ) ->\n    { status, headers } = talos.context.sublime.response\n    if status != 401\n      return false\n    if !( header = headers.get \"www-authenticate\" )?\n      return false\n    directives = WWWAuthenticate.parse header\n    directives = directives.map ({ scheme }) -> scheme\n    \"rune\" in directives\n\n  hasCredentials: ( talos ) ->\n    { response } = talos.context.sublime\n    ( response.headers.get \"credentials\" )?\n\n  hasLocation: ( talos ) ->\n    { headers } = talos.context.sublime.response\n    ( headers.get \"location\" )?\n\n  canPrune: ( talos ) ->\n    { request, response } = talos.context.sublime\n    if !request.headers.authorization?\n      return false\n    if response.contentCategory != \"json\"\n      return false\n    if !response.content?.domain?\n      return false\n    if !response.content?.resource?\n      return false\n    if !response.content?.method?\n      return false\n    true\n\n\nRun =\n  attempt: ( talos ) ->\n    for await current from HTTP.request Value.clone talos.context.input\n      yield current\n    if current.failure\n      throw current.error\n    talos.context.sublime = current.context    \n\n  storeCredentials: ( talos ) ->\n    header = talos.context.sublime.response.headers.get \"credentials\"\n    Credentials.store header\n\n  pullCredentials: ( talos ) ->\n    await Credentials.pull talos.context\n    delete talos.context.input.authorization  # remove email auth literal\n\n  pruneCredentials: ( talos ) ->\n    await Credentials.prune talos.context\n\n  validate: ( talos ) ->\n    await Validate.response talos.context\n\n\nmachine = Machine.make \"vega-client: core\",\n  start: \"attempt\"\n  attempt:\n    run: Run.attempt\n    move: \"authorization\"\n  authorization:\n    retry: When.canRetry\n    credentials:\n      when: When.hasCredentials\n      run: Run.storeCredentials\n      move: \"validate\"\n    default: \"validate\"\n  retry:\n    pullCredentials:\n      priority: 1\n      when: When.hasLocation  \n      run: Run.pullCredentials\n      move: \"attempt\"\n    pruneCredentials:\n      priority: 2\n      when: When.canPrune\n      run: Run.pruneCredentials\n      move: \"attempt\"\n    default: \"validate\"\n  validate:\n    run: Run.validate\n    move: $end\n\n\nrequest = ( context ) -> Async.start machine, input: context\n\n\nCore = {\n  request\n}\n\nexport default Core\nexport {\n  request\n}"],"names":[],"mappings":"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"}

package/build/browser/src/vega-core/validate.js

@@ -0,0 +1,38 @@
+var Validate, indexOf = [].indexOf;
+import { Async } from "@dashkite/talos";
+Validate = {
+    status: function(talos) {
+        var expected, ref, ref1, status;
+        expected = (ref = (ref1 = talos.context.sublime.signatures) != null ? ref1.response.status : void 0) != null ? ref : [
+            200
+        ];
+        ({ status } = talos.context.sublime.response);
+        if (indexOf.call(expected, status) < 0) {
+            throw new Error("unexpected response status");
+        }
+    },
+    contentType: function(talos) {
+        var expected, ref, response, signatures, type;
+        ({ response, signatures } = talos.context.sublime);
+        if (response.content != null) {
+            expected = (ref = signatures.response) != null ? ref["content-type"] : void 0;
+            if (expected == null) {
+                expected = [
+                    "application/json"
+                ];
+            }
+            type = response.headers.get("content-type");
+            if (indexOf.call(expected, type) < 0) {
+                throw new Error("unexpected response content type");
+            }
+        }
+    }
+};
+Validate.response = Async.flow([
+    Validate.status,
+    Validate.contentType
+]);
+export default Validate; //# sourceMappingURL=data:application/json;base64,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
+ //# sourceURL=/@dashkite/vega-client/src/vega-core/validate.coffee
+
+//# sourceMappingURL=data:application/json;base64,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

package/build/browser/src/vega-sky/cache.js

@@ -0,0 +1,55 @@
+var Cache, VegaCache, setEntryExpiration;
+import * as Time from "@dashkite/joy/time";
+VegaCache = void 0;
+setEntryExpiration = async function(url) {
+    await Time.sleep(60 * 1000); // 60 seconds
+    return VegaCache.delete(url);
+};
+Cache = {
+    get: async function(context) {
+        if (VegaCache == null) {
+            VegaCache = await window.caches.open("vega-client");
+        }
+        return await VegaCache.match(context.url.href);
+    },
+    matches: async function(context) {
+        return await Cache.get(context) != null;
+    },
+    put: async function(context) {
+        var body, headers, response, url;
+        if (VegaCache == null) {
+            VegaCache = await window.caches.open("vega-client");
+        }
+        url = context.url.href;
+        body = context.body;
+        headers = {
+            "content-type": context.headers["content-type"],
+            "content-length": "100"
+        };
+        response = new Response(body, {
+            headers
+        });
+        VegaCache.put(url, response);
+        setEntryExpiration(url); // Don't return above promise
+    },
+    delete: async function(context) {
+        var url;
+        if (VegaCache == null) {
+            VegaCache = await window.caches.open("vega-client");
+        }
+        url = context.url.href;
+        return VegaCache.delete(url);
+    },
+    writeback: async function(context) {
+        switch(context.method){
+            case "put":
+                return await Cache.put(context);
+            case "delete":
+                return await Cache.delete(context);
+        }
+    }
+};
+export default Cache; //# sourceMappingURL=data:application/json;base64,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
+ //# sourceURL=/@dashkite/vega-client/src/vega-sky/cache.coffee
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiIiwic291cmNlcyI6WyIvQGRhc2hraXRlL3ZlZ2EtY2xpZW50L3NyYy92ZWdhLXNreS9jYWNoZS5jb2ZmZWUiXSwic291cmNlUm9vdCI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIFRpbWUgZnJvbSBcIkBkYXNoa2l0ZS9qb3kvdGltZVwiXG5cblZlZ2FDYWNoZSA9IHVuZGVmaW5lZFxuXG5zZXRFbnRyeUV4cGlyYXRpb24gPSAoIHVybCApIC0+XG4gIGF3YWl0IFRpbWUuc2xlZXAgNjAgKiAxMDAwICMgNjAgc2Vjb25kc1xuICBWZWdhQ2FjaGUuZGVsZXRlIHVybFxuXG5cbkNhY2hlID1cbiAgZ2V0OiAoIGNvbnRleHQgKSAtPlxuICAgIFZlZ2FDYWNoZSA/PSBhd2FpdCB3aW5kb3cuY2FjaGVzLm9wZW4gXCJ2ZWdhLWNsaWVudFwiXG4gICAgYXdhaXQgVmVnYUNhY2hlLm1hdGNoIGNvbnRleHQudXJsLmhyZWZcbiAgXG4gIG1hdGNoZXM6ICggY29udGV4dCApIC0+XG4gICAgKCBhd2FpdCBDYWNoZS5nZXQgY29udGV4dCApP1xuXG4gIHB1dDogKCBjb250ZXh0ICkgLT5cbiAgICBWZWdhQ2FjaGUgPz0gYXdhaXQgd2luZG93LmNhY2hlcy5vcGVuIFwidmVnYS1jbGllbnRcIlxuICAgIHVybCA9IGNvbnRleHQudXJsLmhyZWZcbiAgICBib2R5ID0gY29udGV4dC5ib2R5XG4gICAgaGVhZGVycyA9IFxuICAgICAgXCJjb250ZW50LXR5cGVcIjogY29udGV4dC5oZWFkZXJzWyBcImNvbnRlbnQtdHlwZVwiIF1cbiAgICAgIFwiY29udGVudC1sZW5ndGhcIjogXCIxMDBcIlxuICAgIHJlc3BvbnNlID0gbmV3IFJlc3BvbnNlIGJvZHksIHsgaGVhZGVycyB9XG4gICAgVmVnYUNhY2hlLnB1dCB1cmwsIHJlc3BvbnNlXG4gICAgc2V0RW50cnlFeHBpcmF0aW9uIHVybFxuICAgIHJldHVybiAgIyBEb24ndCByZXR1cm4gYWJvdmUgcHJvbWlzZVxuXG4gIGRlbGV0ZTogKCBjb250ZXh0ICkgLT5cbiAgICBWZWdhQ2FjaGUgPz0gYXdhaXQgd2luZG93LmNhY2hlcy5vcGVuIFwidmVnYS1jbGllbnRcIlxuICAgIHVybCA9IGNvbnRleHQudXJsLmhyZWZcbiAgICBWZWdhQ2FjaGUuZGVsZXRlIHVybFxuICBcbiAgd3JpdGViYWNrOiAoIGNvbnRleHQgKSAtPlxuICAgIHN3aXRjaCBjb250ZXh0Lm1ldGhvZFxuICAgICAgd2hlbiBcInB1dFwiIHRoZW4gYXdhaXQgQ2FjaGUucHV0IGNvbnRleHRcbiAgICAgIHdoZW4gXCJkZWxldGVcIiB0aGVuIGF3YWl0IENhY2hlLmRlbGV0ZSBjb250ZXh0XG5cblxuZXhwb3J0IGRlZmF1bHQgQ2FjaGUiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsSUFBQSxLQUFBLEVBQUEsU0FBQSxFQUFBO0FBQUEsT0FBTyxDQUFBLElBQUEsSUFBUCxNQUFBLHFCQUFBO0FBRUEsU0FBQSxHQUFZLEtBQUE7QUFFWixrQkFBQSxHQUFxQixNQUFBLFFBQUEsQ0FBRSxHQUFGLENBQUE7SUFDbkIsTUFBTSxJQUFJLENBQUMsS0FBTCxDQUFXLEVBQUEsR0FBSyxJQUFoQixFQUFSLENBQUEsYUFBQTtXQUNFLFNBQVMsQ0FBQyxNQUFWLENBQWlCLEdBQWpCO0FBRm1CO0FBS3JCLEtBQUEsR0FDRTtJQUFBLEdBQUEsRUFBSyxNQUFBLFFBQUEsQ0FBRSxPQUFGLENBQUE7O1lBQ0gsWUFBYSxNQUFNLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBZCxDQUFtQixhQUFuQixDQUFOOztlQUNiLE1BQU0sU0FBUyxDQUFDLEtBQVYsQ0FBZ0IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUE1QixDQUFOO0lBRkcsQ0FBTDtJQUlBLE9BQUEsRUFBUyxNQUFBLFFBQUEsQ0FBRSxPQUFGLENBQUE7ZUFDUCxNQUFBLE1BQUEsR0FBQSxDQUFBLFlBQUE7SUFETyxDQUpUO0lBT0EsR0FBQSxFQUFLLE1BQUEsUUFBQSxDQUFFLE9BQUYsQ0FBQTtRQUNQLElBQUEsSUFBQSxFQUFBLE9BQUEsRUFBQSxRQUFBLEVBQUE7O1lBQUksWUFBYSxNQUFNLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBZCxDQUFtQixhQUFuQixDQUFOOztRQUNiLEdBQUEsR0FBTSxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUE7UUFDbEIsSUFBQSxHQUFPLE9BQU8sQ0FBQyxJQUFBO1FBQ2YsT0FBQSxHQUNFO1lBQUEsY0FBQSxFQUFnQixPQUFPLENBQUMsT0FBTyxDQUFFLGNBQUYsQ0FBL0I7WUFDQSxnQkFBQSxFQUFrQjtRQURsQjtRQUVGLFFBQUEsR0FBVyxJQUFJLFFBQUosQ0FBYSxJQUFiLEVBQW1CO1lBQUU7UUFBRixDQUFuQjtRQUNYLFNBQVMsQ0FBQyxHQUFWLENBQWMsR0FBZCxFQUFtQixRQUFuQjtRQUNBLGtCQUFBLENBQW1CLEdBQW5CLEVBVEcsQ0FBQSw2QkFBQTtJQUFBLENBUEw7SUFtQkEsTUFBQSxFQUFRLE1BQUEsUUFBQSxDQUFFLE9BQUYsQ0FBQTtRQUNWLElBQUE7O1lBQUksWUFBYSxNQUFNLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBZCxDQUFtQixhQUFuQixDQUFOOztRQUNiLEdBQUEsR0FBTSxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUE7ZUFDbEIsU0FBUyxDQUFDLE1BQVYsQ0FBaUIsR0FBakI7SUFITSxDQW5CUjtJQXdCQSxTQUFBLEVBQVcsTUFBQSxRQUFBLENBQUUsT0FBRixDQUFBO1FBQ1QsT0FBTyxPQUFPLENBQUMsTUFBZjtZQUFBLEtBQ08sS0FEUDt1QkFDa0IsTUFBTSxLQUFLLENBQUMsR0FBTixDQUFVLE9BQVYsQ0FBTjtZQURsQixLQUVPLFFBRlA7dUJBRXFCLE1BQU0sS0FBSyxDQUFDLE1BQU4sQ0FBYSxPQUFiLENBQU47UUFGckI7SUFEUztBQXhCWDtBQThCRixPQUFBLFFBQWUsTUFBQSJ9

package/build/browser/src/vega-sky/headers/authorization/email.js

@@ -0,0 +1,54 @@
+var Email, Run, When, machine;
+import { Machine, Sync, $end } from "@dashkite/talos";
+import { Authorization } from "@dashkite/http-headers";
+import Profile from "@dashkite/profile";
+When = {
+    hasEmail: function(talos) {
+        return talos.context.email != null;
+    }
+};
+Run = {
+    read: function(talos) {
+        var email;
+        ({ email } = Profile.load());
+        return talos.context.email = email;
+    },
+    noBuild: function(talos) {
+        throw new Error("no email available");
+    },
+    build: function(talos) {
+        return talos.context.result = Email.fromLiteral(talos.context.email);
+    }
+};
+machine = Machine.make("vega-client: email", {
+    start: "read email from local storage",
+    "read email from local storage": {
+        run: Run.read,
+        move: "select authorization builder"
+    },
+    "select authorization builder": {
+        "use email builder": When.hasEmail,
+        default: "unable to build"
+    },
+    "unable to build": Run.noBuild,
+    "use email builder": Run.build
+});
+Email = {
+    start: function(context) {
+        return Sync.start(machine, {
+            ...context
+        });
+    },
+    fromLiteral: function(email) {
+        return Authorization.format({
+            scheme: "email",
+            parameters: {
+                email
+            }
+        });
+    }
+};
+export default Email; //# sourceMappingURL=data:application/json;base64,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
+ //# sourceURL=/@dashkite/vega-client/src/vega-sky/headers/authorization/email.coffee
+
+//# sourceMappingURL=data:application/json;base64,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