Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2669 insertions, 0 deletions

diff --git a/services/common/kinto-http-client.js b/services/common/kinto-http-client.js
new file mode 100644
index 0000000000..d035592370
--- /dev/null
+++ b/services/common/kinto-http-client.js
@@ -0,0 +1,2669 @@
+/*
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+
+/*
+ * This file is generated from kinto-http.js - do not modify directly.
+ */
+
+const global = this;
+
+var EXPORTED_SYMBOLS = ["KintoHttpClient"];
+
+const { setTimeout, clearTimeout } = ChromeUtils.import("resource://gre/modules/Timer.jsm");
+const { XPCOMUtils } = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyGlobalGetters(global, ["fetch"]);
+
+/*
+ * Version 5.1.1 - 30c540a
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = global || self, global.KintoHttpClient = factory());
+}(this, (function () { 'use strict';
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation. All rights reserved.
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at http://www.apache.org/licenses/LICENSE-2.0
+
+    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+    MERCHANTABLITY OR NON-INFRINGEMENT.
+
+    See the Apache Version 2.0 License for specific language governing permissions
+    and limitations under the License.
+    ***************************************************************************** */
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    /**
+     * Chunks an array into n pieces.
+     *
+     * @private
+     * @param  {Array}  array
+     * @param  {Number} n
+     * @return {Array}
+     */
+    function partition(array, n) {
+        if (n <= 0) {
+            return [array];
+        }
+        return array.reduce((acc, x, i) => {
+            if (i === 0 || i % n === 0) {
+                acc.push([x]);
+            }
+            else {
+                acc[acc.length - 1].push(x);
+            }
+            return acc;
+        }, []);
+    }
+    /**
+     * Returns a Promise always resolving after the specified amount in milliseconds.
+     *
+     * @return Promise<void>
+     */
+    function delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Always returns a resource data object from the provided argument.
+     *
+     * @private
+     * @param  {Object|String} resource
+     * @return {Object}
+     */
+    function toDataBody(resource) {
+        if (isObject(resource)) {
+            return resource;
+        }
+        if (typeof resource === "string") {
+            return { id: resource };
+        }
+        throw new Error("Invalid argument.");
+    }
+    /**
+     * Transforms an object into an URL query string, stripping out any undefined
+     * values.
+     *
+     * @param  {Object} obj
+     * @return {String}
+     */
+    function qsify(obj) {
+        const encode = (v) => encodeURIComponent(typeof v === "boolean" ? String(v) : v);
+        const stripped = cleanUndefinedProperties(obj);
+        return Object.keys(stripped)
+            .map((k) => {
+            const ks = encode(k) + "=";
+            if (Array.isArray(stripped[k])) {
+                return ks + stripped[k].map((v) => encode(v)).join(",");
+            }
+            else {
+                return ks + encode(stripped[k]);
+            }
+        })
+            .join("&");
+    }
+    /**
+     * Checks if a version is within the provided range.
+     *
+     * @param  {String} version    The version to check.
+     * @param  {String} minVersion The minimum supported version (inclusive).
+     * @param  {String} maxVersion The minimum supported version (exclusive).
+     * @throws {Error} If the version is outside of the provided range.
+     */
+    function checkVersion(version, minVersion, maxVersion) {
+        const extract = (str) => str.split(".").map((x) => parseInt(x, 10));
+        const [verMajor, verMinor] = extract(version);
+        const [minMajor, minMinor] = extract(minVersion);
+        const [maxMajor, maxMinor] = extract(maxVersion);
+        const checks = [
+            verMajor < minMajor,
+            verMajor === minMajor && verMinor < minMinor,
+            verMajor > maxMajor,
+            verMajor === maxMajor && verMinor >= maxMinor,
+        ];
+        if (checks.some((x) => x)) {
+            throw new Error(`Version ${version} doesn't satisfy ${minVersion} <= x < ${maxVersion}`);
+        }
+    }
+    /**
+     * Generates a decorator function ensuring a version check is performed against
+     * the provided requirements before executing it.
+     *
+     * @param  {String} min The required min version (inclusive).
+     * @param  {String} max The required max version (inclusive).
+     * @return {Function}
+     */
+    function support(min, max) {
+        return function (
+        // @ts-ignore
+        target, key, descriptor) {
+            const fn = descriptor.value;
+            return {
+                configurable: true,
+                get() {
+                    const wrappedMethod = (...args) => {
+                        // "this" is the current instance which its method is decorated.
+                        const client = this.client ? this.client : this;
+                        return client
+                            .fetchHTTPApiVersion()
+                            .then((version) => checkVersion(version, min, max))
+                            .then(() => fn.apply(this, args));
+                    };
+                    Object.defineProperty(this, key, {
+                        value: wrappedMethod,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return wrappedMethod;
+                },
+            };
+        };
+    }
+    /**
+     * Generates a decorator function ensuring that the specified capabilities are
+     * available on the server before executing it.
+     *
+     * @param  {Array<String>} capabilities The required capabilities.
+     * @return {Function}
+     */
+    function capable(capabilities) {
+        return function (
+        // @ts-ignore
+        target, key, descriptor) {
+            const fn = descriptor.value;
+            return {
+                configurable: true,
+                get() {
+                    const wrappedMethod = (...args) => {
+                        // "this" is the current instance which its method is decorated.
+                        const client = this.client ? this.client : this;
+                        return client
+                            .fetchServerCapabilities()
+                            .then((available) => {
+                            const missing = capabilities.filter((c) => !(c in available));
+                            if (missing.length > 0) {
+                                const missingStr = missing.join(", ");
+                                throw new Error(`Required capabilities ${missingStr} not present on server`);
+                            }
+                        })
+                            .then(() => fn.apply(this, args));
+                    };
+                    Object.defineProperty(this, key, {
+                        value: wrappedMethod,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return wrappedMethod;
+                },
+            };
+        };
+    }
+    /**
+     * Generates a decorator function ensuring an operation is not performed from
+     * within a batch request.
+     *
+     * @param  {String} message The error message to throw.
+     * @return {Function}
+     */
+    function nobatch(message) {
+        return function (
+        // @ts-ignore
+        target, key, descriptor) {
+            const fn = descriptor.value;
+            return {
+                configurable: true,
+                get() {
+                    const wrappedMethod = (...args) => {
+                        // "this" is the current instance which its method is decorated.
+                        if (this._isBatch) {
+                            throw new Error(message);
+                        }
+                        return fn.apply(this, args);
+                    };
+                    Object.defineProperty(this, key, {
+                        value: wrappedMethod,
+                        configurable: true,
+                        writable: true,
+                    });
+                    return wrappedMethod;
+                },
+            };
+        };
+    }
+    /**
+     * Returns true if the specified value is an object (i.e. not an array nor null).
+     * @param  {Object} thing The value to inspect.
+     * @return {bool}
+     */
+    function isObject(thing) {
+        return typeof thing === "object" && thing !== null && !Array.isArray(thing);
+    }
+    /**
+     * Parses a data url.
+     * @param  {String} dataURL The data url.
+     * @return {Object}
+     */
+    function parseDataURL(dataURL) {
+        const regex = /^data:(.*);base64,(.*)/;
+        const match = dataURL.match(regex);
+        if (!match) {
+            throw new Error(`Invalid data-url: ${String(dataURL).substr(0, 32)}...`);
+        }
+        const props = match[1];
+        const base64 = match[2];
+        const [type, ...rawParams] = props.split(";");
+        const params = rawParams.reduce((acc, param) => {
+            const [key, value] = param.split("=");
+            return Object.assign(Object.assign({}, acc), { [key]: value });
+        }, {});
+        return Object.assign(Object.assign({}, params), { type, base64 });
+    }
+    /**
+     * Extracts file information from a data url.
+     * @param  {String} dataURL The data url.
+     * @return {Object}
+     */
+    function extractFileInfo(dataURL) {
+        const { name, type, base64 } = parseDataURL(dataURL);
+        const binary = atob(base64);
+        const array = [];
+        for (let i = 0; i < binary.length; i++) {
+            array.push(binary.charCodeAt(i));
+        }
+        const blob = new Blob([new Uint8Array(array)], { type });
+        return { blob, name };
+    }
+    /**
+     * Creates a FormData instance from a data url and an existing JSON response
+     * body.
+     * @param  {String} dataURL            The data url.
+     * @param  {Object} body               The response body.
+     * @param  {Object} [options={}]       The options object.
+     * @param  {Object} [options.filename] Force attachment file name.
+     * @return {FormData}
+     */
+    function createFormData(dataURL, body, options = {}) {
+        const { filename = "untitled" } = options;
+        const { blob, name } = extractFileInfo(dataURL);
+        const formData = new FormData();
+        formData.append("attachment", blob, name || filename);
+        for (const property in body) {
+            if (typeof body[property] !== "undefined") {
+                formData.append(property, JSON.stringify(body[property]));
+            }
+        }
+        return formData;
+    }
+    /**
+     * Clones an object with all its undefined keys removed.
+     * @private
+     */
+    function cleanUndefinedProperties(obj) {
+        const result = {};
+        for (const key in obj) {
+            if (typeof obj[key] !== "undefined") {
+                result[key] = obj[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * Handle common query parameters for Kinto requests.
+     *
+     * @param  {String}  [path]  The endpoint base path.
+     * @param  {Array}   [options.fields]    Fields to limit the
+     *   request to.
+     * @param  {Object}  [options.query={}]  Additional query arguments.
+     */
+    function addEndpointOptions(path, options = {}) {
+        const query = Object.assign({}, options.query);
+        if (options.fields) {
+            query._fields = options.fields;
+        }
+        const queryString = qsify(query);
+        if (queryString) {
+            return path + "?" + queryString;
+        }
+        return path;
+    }
+    /**
+     * Replace authorization header with an obscured version
+     */
+    function obscureAuthorizationHeader(headers) {
+        const h = new Headers(headers);
+        if (h.has("authorization")) {
+            h.set("authorization", "**** (suppressed)");
+        }
+        const obscuredHeaders = {};
+        for (const [header, value] of h.entries()) {
+            obscuredHeaders[header] = value;
+        }
+        return obscuredHeaders;
+    }
+
+    /**
+     * Kinto server error code descriptors.
+     */
+    const ERROR_CODES = {
+        104: "Missing Authorization Token",
+        105: "Invalid Authorization Token",
+        106: "Request body was not valid JSON",
+        107: "Invalid request parameter",
+        108: "Missing request parameter",
+        109: "Invalid posted data",
+        110: "Invalid Token / id",
+        111: "Missing Token / id",
+        112: "Content-Length header was not provided",
+        113: "Request body too large",
+        114: "Resource was created, updated or deleted meanwhile",
+        115: "Method not allowed on this end point (hint: server may be readonly)",
+        116: "Requested version not available on this server",
+        117: "Client has sent too many requests",
+        121: "Resource access is forbidden for this user",
+        122: "Another resource violates constraint",
+        201: "Service Temporary unavailable due to high load",
+        202: "Service deprecated",
+        999: "Internal Server Error",
+    };
+    class NetworkTimeoutError extends Error {
+        constructor(url, options) {
+            super(`Timeout while trying to access ${url} with ${JSON.stringify(options)}`);
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, NetworkTimeoutError);
+            }
+            this.url = url;
+            this.options = options;
+        }
+    }
+    class UnparseableResponseError extends Error {
+        constructor(response, body, error) {
+            const { status } = response;
+            super(`Response from server unparseable (HTTP ${status || 0}; ${error}): ${body}`);
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, UnparseableResponseError);
+            }
+            this.status = status;
+            this.response = response;
+            this.stack = error.stack;
+            this.error = error;
+        }
+    }
+    /**
+     * "Error" subclass representing a >=400 response from the server.
+     *
+     * Whether or not this is an error depends on your application.
+     *
+     * The `json` field can be undefined if the server responded with an
+     * empty response body. This shouldn't generally happen. Most "bad"
+     * responses come with a JSON error description, or (if they're
+     * fronted by a CDN or nginx or something) occasionally non-JSON
+     * responses (which become UnparseableResponseErrors, above).
+     */
+    class ServerResponse extends Error {
+        constructor(response, json) {
+            const { status } = response;
+            let { statusText } = response;
+            let errnoMsg;
+            if (json) {
+                // Try to fill in information from the JSON error.
+                statusText = json.error || statusText;
+                // Take errnoMsg from either ERROR_CODES or json.message.
+                if (json.errno && json.errno in ERROR_CODES) {
+                    errnoMsg = ERROR_CODES[json.errno];
+                }
+                else if (json.message) {
+                    errnoMsg = json.message;
+                }
+                // If we had both ERROR_CODES and json.message, and they differ,
+                // combine them.
+                if (errnoMsg && json.message && json.message !== errnoMsg) {
+                    errnoMsg += ` (${json.message})`;
+                }
+            }
+            let message = `HTTP ${status} ${statusText}`;
+            if (errnoMsg) {
+                message += `: ${errnoMsg}`;
+            }
+            super(message.trim());
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, ServerResponse);
+            }
+            this.response = response;
+            this.data = json;
+        }
+    }
+
+    var errors = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        'default': ERROR_CODES,
+        NetworkTimeoutError: NetworkTimeoutError,
+        ServerResponse: ServerResponse,
+        UnparseableResponseError: UnparseableResponseError
+    });
+
+    /**
+     * Enhanced HTTP client for the Kinto protocol.
+     * @private
+     */
+    class HTTP {
+        /**
+         * Constructor.
+         *
+         * @param {EventEmitter} events                       The event handler.
+         * @param {Object}       [options={}}                 The options object.
+         * @param {Number}       [options.timeout=null]       The request timeout in ms, if any (default: `null`).
+         * @param {String}       [options.requestMode="cors"] The HTTP request mode (default: `"cors"`).
+         */
+        constructor(events, options = {}) {
+            // public properties
+            /**
+             * The event emitter instance.
+             * @type {EventEmitter}
+             */
+            this.events = events;
+            /**
+             * The request mode.
+             * @see  https://fetch.spec.whatwg.org/#requestmode
+             * @type {String}
+             */
+            this.requestMode = options.requestMode || HTTP.defaultOptions.requestMode;
+            /**
+             * The request timeout.
+             * @type {Number}
+             */
+            this.timeout = options.timeout || HTTP.defaultOptions.timeout;
+        }
+        /**
+         * Default HTTP request headers applied to each outgoing request.
+         *
+         * @type {Object}
+         */
+        static get DEFAULT_REQUEST_HEADERS() {
+            return {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+            };
+        }
+        /**
+         * Default options.
+         *
+         * @type {Object}
+         */
+        static get defaultOptions() {
+            return { timeout: null, requestMode: "cors" };
+        }
+        /**
+         * @private
+         */
+        timedFetch(url, options) {
+            let hasTimedout = false;
+            return new Promise((resolve, reject) => {
+                // Detect if a request has timed out.
+                let _timeoutId;
+                if (this.timeout) {
+                    _timeoutId = setTimeout(() => {
+                        hasTimedout = true;
+                        if (options && options.headers) {
+                            options = Object.assign(Object.assign({}, options), { headers: obscureAuthorizationHeader(options.headers) });
+                        }
+                        reject(new NetworkTimeoutError(url, options));
+                    }, this.timeout);
+                }
+                function proceedWithHandler(fn) {
+                    return (arg) => {
+                        if (!hasTimedout) {
+                            if (_timeoutId) {
+                                clearTimeout(_timeoutId);
+                            }
+                            fn(arg);
+                        }
+                    };
+                }
+                fetch(url, options)
+                    .then(proceedWithHandler(resolve))
+                    .catch(proceedWithHandler(reject));
+            });
+        }
+        /**
+         * @private
+         */
+        async processResponse(response) {
+            const { status, headers } = response;
+            const text = await response.text();
+            // Check if we have a body; if so parse it as JSON.
+            let json;
+            if (text.length !== 0) {
+                try {
+                    json = JSON.parse(text);
+                }
+                catch (err) {
+                    throw new UnparseableResponseError(response, text, err);
+                }
+            }
+            if (status >= 400) {
+                throw new ServerResponse(response, json);
+            }
+            return { status, json: json, headers };
+        }
+        /**
+         * @private
+         */
+        async retry(url, retryAfter, request, options) {
+            await delay(retryAfter);
+            return this.request(url, request, Object.assign(Object.assign({}, options), { retry: options.retry - 1 }));
+        }
+        /**
+         * Performs an HTTP request to the Kinto server.
+         *
+         * Resolves with an objet containing the following HTTP response properties:
+         * - `{Number}  status`  The HTTP status code.
+         * - `{Object}  json`    The JSON response body.
+         * - `{Headers} headers` The response headers object; see the ES6 fetch() spec.
+         *
+         * @param  {String} url               The URL.
+         * @param  {Object} [request={}]      The request object, passed to
+         *     fetch() as its options object.
+         * @param  {Object} [request.headers] The request headers object (default: {})
+         * @param  {Object} [options={}]      Options for making the
+         *     request
+         * @param  {Number} [options.retry]   Number of retries (default: 0)
+         * @return {Promise}
+         */
+        async request(url, request = { headers: {} }, options = { retry: 0 }) {
+            // Ensure default request headers are always set
+            request.headers = Object.assign(Object.assign({}, HTTP.DEFAULT_REQUEST_HEADERS), request.headers);
+            // If a multipart body is provided, remove any custom Content-Type header as
+            // the fetch() implementation will add the correct one for us.
+            if (request.body && request.body instanceof FormData) {
+                if (request.headers instanceof Headers) {
+                    request.headers.delete("Content-Type");
+                }
+                else if (!Array.isArray(request.headers)) {
+                    delete request.headers["Content-Type"];
+                }
+            }
+            request.mode = this.requestMode;
+            const response = await this.timedFetch(url, request);
+            const { headers } = response;
+            this._checkForDeprecationHeader(headers);
+            this._checkForBackoffHeader(headers);
+            // Check if the server summons the client to retry after a while.
+            const retryAfter = this._checkForRetryAfterHeader(headers);
+            // If number of allowed of retries is not exhausted, retry the same request.
+            if (retryAfter && options.retry > 0) {
+                return this.retry(url, retryAfter, request, options);
+            }
+            else {
+                return this.processResponse(response);
+            }
+        }
+        _checkForDeprecationHeader(headers) {
+            const alertHeader = headers.get("Alert");
+            if (!alertHeader) {
+                return;
+            }
+            let alert;
+            try {
+                alert = JSON.parse(alertHeader);
+            }
+            catch (err) {
+                console.warn("Unable to parse Alert header message", alertHeader);
+                return;
+            }
+            console.warn(alert.message, alert.url);
+            if (this.events) {
+                this.events.emit("deprecated", alert);
+            }
+        }
+        _checkForBackoffHeader(headers) {
+            let backoffMs;
+            const backoffHeader = headers.get("Backoff");
+            const backoffSeconds = backoffHeader ? parseInt(backoffHeader, 10) : 0;
+            if (backoffSeconds > 0) {
+                backoffMs = new Date().getTime() + backoffSeconds * 1000;
+            }
+            else {
+                backoffMs = 0;
+            }
+            if (this.events) {
+                this.events.emit("backoff", backoffMs);
+            }
+        }
+        _checkForRetryAfterHeader(headers) {
+            const retryAfter = headers.get("Retry-After");
+            if (!retryAfter) {
+                return;
+            }
+            const delay = parseInt(retryAfter, 10) * 1000;
+            const tryAgainAfter = new Date().getTime() + delay;
+            if (this.events) {
+                this.events.emit("retry-after", tryAgainAfter);
+            }
+            return delay;
+        }
+    }
+
+    /**
+     * Endpoints templates.
+     * @type {Object}
+     */
+    const ENDPOINTS = {
+        root: () => "/",
+        batch: () => "/batch",
+        permissions: () => "/permissions",
+        bucket: (bucket) => "/buckets" + (bucket ? `/${bucket}` : ""),
+        history: (bucket) => `${ENDPOINTS.bucket(bucket)}/history`,
+        collection: (bucket, coll) => `${ENDPOINTS.bucket(bucket)}/collections` + (coll ? `/${coll}` : ""),
+        group: (bucket, group) => `${ENDPOINTS.bucket(bucket)}/groups` + (group ? `/${group}` : ""),
+        record: (bucket, coll, id) => `${ENDPOINTS.collection(bucket, coll)}/records` + (id ? `/${id}` : ""),
+        attachment: (bucket, coll, id) => `${ENDPOINTS.record(bucket, coll, id)}/attachment`,
+    };
+
+    const requestDefaults = {
+        safe: false,
+        // check if we should set default content type here
+        headers: {},
+        patch: false,
+    };
+    /**
+     * @private
+     */
+    function safeHeader(safe, last_modified) {
+        if (!safe) {
+            return {};
+        }
+        if (last_modified) {
+            return { "If-Match": `"${last_modified}"` };
+        }
+        return { "If-None-Match": "*" };
+    }
+    /**
+     * @private
+     */
+    function createRequest(path, { data, permissions }, options = {}) {
+        const { headers, safe } = Object.assign(Object.assign({}, requestDefaults), options);
+        const method = options.method || (data && data.id) ? "PUT" : "POST";
+        return {
+            method,
+            path,
+            headers: Object.assign(Object.assign({}, headers), safeHeader(safe)),
+            body: { data, permissions },
+        };
+    }
+    /**
+     * @private
+     */
+    function updateRequest(path, { data, permissions }, options = {}) {
+        const { headers, safe, patch } = Object.assign(Object.assign({}, requestDefaults), options);
+        const { last_modified } = Object.assign(Object.assign({}, data), options);
+        const hasNoData = data &&
+            Object.keys(data).filter((k) => k !== "id" && k !== "last_modified")
+                .length === 0;
+        if (hasNoData) {
+            data = undefined;
+        }
+        return {
+            method: patch ? "PATCH" : "PUT",
+            path,
+            headers: Object.assign(Object.assign({}, headers), safeHeader(safe, last_modified)),
+            body: { data, permissions },
+        };
+    }
+    /**
+     * @private
+     */
+    function jsonPatchPermissionsRequest(path, permissions, opType, options = {}) {
+        const { headers, safe, last_modified } = Object.assign(Object.assign({}, requestDefaults), options);
+        const ops = [];
+        for (const [type, principals] of Object.entries(permissions)) {
+            if (principals) {
+                for (const principal of principals) {
+                    ops.push({
+                        op: opType,
+                        path: `/permissions/${type}/${principal}`,
+                    });
+                }
+            }
+        }
+        return {
+            method: "PATCH",
+            path,
+            headers: Object.assign(Object.assign(Object.assign({}, headers), safeHeader(safe, last_modified)), { "Content-Type": "application/json-patch+json" }),
+            body: ops,
+        };
+    }
+    /**
+     * @private
+     */
+    function deleteRequest(path, options = {}) {
+        const { headers, safe, last_modified } = Object.assign(Object.assign({}, requestDefaults), options);
+        if (safe && !last_modified) {
+            throw new Error("Safe concurrency check requires a last_modified value.");
+        }
+        return {
+            method: "DELETE",
+            path,
+            headers: Object.assign(Object.assign({}, headers), safeHeader(safe, last_modified)),
+        };
+    }
+    /**
+     * @private
+     */
+    function addAttachmentRequest(path, dataURI, { data, permissions } = {}, options = {}) {
+        const { headers, safe, gzipped } = Object.assign(Object.assign({}, requestDefaults), options);
+        const { last_modified } = Object.assign(Object.assign({}, data), options);
+        const body = { data, permissions };
+        const formData = createFormData(dataURI, body, options);
+        const customPath = `${path}${gzipped !== null ? "?gzipped=" + (gzipped ? "true" : "false") : ""}`;
+        return {
+            method: "POST",
+            path: customPath,
+            headers: Object.assign(Object.assign({}, headers), safeHeader(safe, last_modified)),
+            body: formData,
+        };
+    }
+
+    /**
+     * Exports batch responses as a result object.
+     *
+     * @private
+     * @param  {Array} responses The batch subrequest responses.
+     * @param  {Array} requests  The initial issued requests.
+     * @return {Object}
+     */
+    function aggregate(responses = [], requests = []) {
+        if (responses.length !== requests.length) {
+            throw new Error("Responses length should match requests one.");
+        }
+        const results = {
+            errors: [],
+            published: [],
+            conflicts: [],
+            skipped: [],
+        };
+        return responses.reduce((acc, response, index) => {
+            const { status } = response;
+            const request = requests[index];
+            if (status >= 200 && status < 400) {
+                acc.published.push(response.body);
+            }
+            else if (status === 404) {
+                // Extract the id manually from request path while waiting for Kinto/kinto#818
+                const regex = /(buckets|groups|collections|records)\/([^/]+)$/;
+                const extracts = request.path.match(regex);
+                const id = extracts && extracts.length === 3 ? extracts[2] : undefined;
+                acc.skipped.push({
+                    id,
+                    path: request.path,
+                    error: response.body,
+                });
+            }
+            else if (status === 412) {
+                acc.conflicts.push({
+                    // XXX: specifying the type is probably superfluous
+                    type: "outgoing",
+                    local: request.body,
+                    remote: (response.body.details && response.body.details.existing) || null,
+                });
+            }
+            else {
+                acc.errors.push({
+                    path: request.path,
+                    sent: request,
+                    error: response.body,
+                });
+            }
+            return acc;
+        }, results);
+    }
+
+    // Unique ID creation requires a high quality random # generator. In the browser we therefore
+    // require the crypto API and do not support built-in fallback to lower quality random number
+    // generators (like Math.random()).
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    var getRandomValues = typeof crypto != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != 'undefined' && typeof msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto);
+    var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
+    function rng() {
+        if (!getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        return getRandomValues(rnds8);
+    }
+
+    /**
+     * Convert array of 16 byte values to UUID string format of the form:
+     * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+     */
+    var byteToHex = [];
+    for (var i = 0; i < 256; ++i) {
+        byteToHex[i] = (i + 0x100).toString(16).substr(1);
+    }
+    function bytesToUuid(buf, offset) {
+        var i = offset || 0;
+        var bth = byteToHex; // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
+        return [bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]]].join('');
+    }
+
+    function v4(options, buf, offset) {
+        var i = buf && offset || 0;
+        if (typeof options == 'string') {
+            buf = options === 'binary' ? new Array(16) : null;
+            options = null;
+        }
+        options = options || {};
+        var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+        rnds[6] = rnds[6] & 0x0f | 0x40;
+        rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+        if (buf) {
+            for (var ii = 0; ii < 16; ++ii) {
+                buf[i + ii] = rnds[ii];
+            }
+        }
+        return buf || bytesToUuid(rnds);
+    }
+
+    /**
+     * Abstract representation of a selected collection.
+     *
+     */
+    class Collection {
+        /**
+         * Constructor.
+         *
+         * @param  {KintoClient}  client            The client instance.
+         * @param  {Bucket}       bucket            The bucket instance.
+         * @param  {String}       name              The collection name.
+         * @param  {Object}       [options={}]      The options object.
+         * @param  {Object}       [options.headers] The headers object option.
+         * @param  {Boolean}      [options.safe]    The safe option.
+         * @param  {Number}       [options.retry]   The retry option.
+         * @param  {Boolean}      [options.batch]   (Private) Whether this
+         *     Collection is operating as part of a batch.
+         */
+        constructor(client, bucket, name, options = {}) {
+            /**
+             * @ignore
+             */
+            this.client = client;
+            /**
+             * @ignore
+             */
+            this.bucket = bucket;
+            /**
+             * The collection name.
+             * @type {String}
+             */
+            this.name = name;
+            this._endpoints = client.endpoints;
+            /**
+             * @ignore
+             */
+            this._retry = options.retry || 0;
+            this._safe = !!options.safe;
+            // FIXME: This is kind of ugly; shouldn't the bucket be responsible
+            // for doing the merge?
+            this._headers = Object.assign(Object.assign({}, this.bucket.headers), options.headers);
+        }
+        get execute() {
+            return this.client.execute.bind(this.client);
+        }
+        /**
+         * Get the value of "headers" for a given request, merging the
+         * per-request headers with our own "default" headers.
+         *
+         * @private
+         */
+        _getHeaders(options) {
+            return Object.assign(Object.assign({}, this._headers), options.headers);
+        }
+        /**
+         * Get the value of "safe" for a given request, using the
+         * per-request option if present or falling back to our default
+         * otherwise.
+         *
+         * @private
+         * @param {Object} options The options for a request.
+         * @returns {Boolean}
+         */
+        _getSafe(options) {
+            return Object.assign({ safe: this._safe }, options).safe;
+        }
+        /**
+         * As _getSafe, but for "retry".
+         *
+         * @private
+         */
+        _getRetry(options) {
+            return Object.assign({ retry: this._retry }, options).retry;
+        }
+        /**
+         * Retrieves the total number of records in this collection.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Number, Error>}
+         */
+        async getTotalRecords(options = {}) {
+            const path = this._endpoints.record(this.bucket.name, this.name);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+                method: "HEAD",
+            };
+            const { headers } = await this.client.execute(request, {
+                raw: true,
+                retry: this._getRetry(options),
+            });
+            return parseInt(headers.get("Total-Records"), 10);
+        }
+        /**
+         * Retrieves the ETag of the records list, for use with the `since` filtering option.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<String, Error>}
+         */
+        async getRecordsTimestamp(options = {}) {
+            const path = this._endpoints.record(this.bucket.name, this.name);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+                method: "HEAD",
+            };
+            const { headers } = (await this.client.execute(request, {
+                raw: true,
+                retry: this._getRetry(options),
+            }));
+            return headers.get("ETag");
+        }
+        /**
+         * Retrieves collection data.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Object} [options.query]   Query parameters to pass in
+         *     the request. This might be useful for features that aren't
+         *     yet supported by this library.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async getData(options = {}) {
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const request = { headers: this._getHeaders(options), path };
+            const { data } = (await this.client.execute(request, {
+                retry: this._getRetry(options),
+                query: options.query,
+                fields: options.fields,
+            }));
+            return data;
+        }
+        /**
+         * Set collection data.
+         * @param  {Object}   data                    The collection data object.
+         * @param  {Object}   [options={}]            The options object.
+         * @param  {Object}   [options.headers]       The headers object option.
+         * @param  {Number}   [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean}  [options.safe]          The safe option.
+         * @param  {Boolean}  [options.patch]         The patch option.
+         * @param  {Number}   [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async setData(data, options = {}) {
+            if (!isObject(data)) {
+                throw new Error("A collection object is required.");
+            }
+            const { patch, permissions } = options;
+            const { last_modified } = Object.assign(Object.assign({}, data), options);
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const request = updateRequest(path, { data, permissions }, {
+                last_modified,
+                patch,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of permissions for this collection.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async getPermissions(options = {}) {
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const request = { headers: this._getHeaders(options), path };
+            const { permissions } = (await this.client.execute(request, {
+                retry: this._getRetry(options),
+            }));
+            return permissions;
+        }
+        /**
+         * Replaces all existing collection permissions with the ones provided.
+         *
+         * @param  {Object}   permissions             The permissions object.
+         * @param  {Object}   [options={}]            The options object
+         * @param  {Object}   [options.headers]       The headers object option.
+         * @param  {Number}   [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean}  [options.safe]          The safe option.
+         * @param  {Number}   [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async setPermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const data = { last_modified: options.last_modified };
+            const request = updateRequest(path, { data, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Append principals to the collection permissions.
+         *
+         * @param  {Object}  permissions             The permissions object.
+         * @param  {Object}  [options={}]            The options object
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async addPermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const { last_modified } = options;
+            const request = jsonPatchPermissionsRequest(path, permissions, "add", {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Remove principals from the collection permissions.
+         *
+         * @param  {Object}  permissions             The permissions object.
+         * @param  {Object}  [options={}]            The options object
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async removePermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.collection(this.bucket.name, this.name);
+            const { last_modified } = options;
+            const request = jsonPatchPermissionsRequest(path, permissions, "remove", {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Creates a record in current collection.
+         *
+         * @param  {Object}  record                The record to create.
+         * @param  {Object}  [options={}]          The options object.
+         * @param  {Object}  [options.headers]     The headers object option.
+         * @param  {Number}  [options.retry=0]     Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean} [options.safe]        The safe option.
+         * @param  {Object}  [options.permissions] The permissions option.
+         * @return {Promise<Object, Error>}
+         */
+        async createRecord(record, options = {}) {
+            const { permissions } = options;
+            const path = this._endpoints.record(this.bucket.name, this.name, record.id);
+            const request = createRequest(path, { data: record, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Adds an attachment to a record, creating the record when it doesn't exist.
+         *
+         * @param  {String}  dataURL                 The data url.
+         * @param  {Object}  [record={}]             The record data.
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         * @param  {Object}  [options.permissions]   The permissions option.
+         * @param  {String}  [options.filename]      Force the attachment filename.
+         * @param  {String}  [options.gzipped]       Force the attachment to be gzipped or not.
+         * @return {Promise<Object, Error>}
+         */
+        async addAttachment(dataURI, record = {}, options = {}) {
+            const { permissions } = options;
+            const id = record.id || v4();
+            const path = this._endpoints.attachment(this.bucket.name, this.name, id);
+            const { last_modified } = Object.assign(Object.assign({}, record), options);
+            const addAttachmentRequest$1 = addAttachmentRequest(path, dataURI, { data: record, permissions }, {
+                last_modified,
+                filename: options.filename,
+                gzipped: options.gzipped,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            await this.client.execute(addAttachmentRequest$1, {
+                stringify: false,
+                retry: this._getRetry(options),
+            });
+            return this.getRecord(id);
+        }
+        /**
+         * Removes an attachment from a given record.
+         *
+         * @param  {Object}  recordId                The record id.
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         */
+        async removeAttachment(recordId, options = {}) {
+            const { last_modified } = options;
+            const path = this._endpoints.attachment(this.bucket.name, this.name, recordId);
+            const request = deleteRequest(path, {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Updates a record in current collection.
+         *
+         * @param  {Object}  record                  The record to update.
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         * @param  {Object}  [options.permissions]   The permissions option.
+         * @return {Promise<Object, Error>}
+         */
+        async updateRecord(record, options = {}) {
+            if (!isObject(record)) {
+                throw new Error("A record object is required.");
+            }
+            if (!record.id) {
+                throw new Error("A record id is required.");
+            }
+            const { permissions } = options;
+            const { last_modified } = Object.assign(Object.assign({}, record), options);
+            const path = this._endpoints.record(this.bucket.name, this.name, record.id);
+            const request = updateRequest(path, { data: record, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+                last_modified,
+                patch: !!options.patch,
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Deletes a record from the current collection.
+         *
+         * @param  {Object|String} record                  The record to delete.
+         * @param  {Object}        [options={}]            The options object.
+         * @param  {Object}        [options.headers]       The headers object option.
+         * @param  {Number}        [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean}       [options.safe]          The safe option.
+         * @param  {Number}        [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async deleteRecord(record, options = {}) {
+            const recordObj = toDataBody(record);
+            if (!recordObj.id) {
+                throw new Error("A record id is required.");
+            }
+            const { id } = recordObj;
+            const { last_modified } = Object.assign(Object.assign({}, recordObj), options);
+            const path = this._endpoints.record(this.bucket.name, this.name, id);
+            const request = deleteRequest(path, {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves a record from the current collection.
+         *
+         * @param  {String} id                The record id to retrieve.
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Object} [options.query]   Query parameters to pass in
+         *     the request. This might be useful for features that aren't
+         *     yet supported by this library.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async getRecord(id, options = {}) {
+            const path = this._endpoints.record(this.bucket.name, this.name, id);
+            const request = { headers: this._getHeaders(options), path };
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+                query: options.query,
+                fields: options.fields,
+            });
+        }
+        /**
+         * Lists records from the current collection.
+         *
+         * Sorting is done by passing a `sort` string option:
+         *
+         * - The field to order the results by, prefixed with `-` for descending.
+         * Default: `-last_modified`.
+         *
+         * @see http://kinto.readthedocs.io/en/stable/api/1.x/sorting.html
+         *
+         * Filtering is done by passing a `filters` option object:
+         *
+         * - `{fieldname: "value"}`
+         * - `{min_fieldname: 4000}`
+         * - `{in_fieldname: "1,2,3"}`
+         * - `{not_fieldname: 0}`
+         * - `{exclude_fieldname: "0,1"}`
+         *
+         * @see http://kinto.readthedocs.io/en/stable/api/1.x/filtering.html
+         *
+         * Paginating is done by passing a `limit` option, then calling the `next()`
+         * method from the resolved result object to fetch the next page, if any.
+         *
+         * @param  {Object}   [options={}]                    The options object.
+         * @param  {Object}   [options.headers]               The headers object option.
+         * @param  {Number}   [options.retry=0]               Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}   [options.filters={}]            The filters object.
+         * @param  {String}   [options.sort="-last_modified"] The sort field.
+         * @param  {String}   [options.at]                    The timestamp to get a snapshot at.
+         * @param  {String}   [options.limit=null]            The limit field.
+         * @param  {String}   [options.pages=1]               The number of result pages to aggregate.
+         * @param  {Number}   [options.since=null]            Only retrieve records modified since the provided timestamp.
+         * @param  {Array}    [options.fields]                Limit response to just some fields.
+         * @return {Promise<Object, Error>}
+         */
+        async listRecords(options = {}) {
+            const path = this._endpoints.record(this.bucket.name, this.name);
+            if (options.at) {
+                return this.getSnapshot(options.at);
+            }
+            else {
+                return this.client.paginatedList(path, options, {
+                    headers: this._getHeaders(options),
+                    retry: this._getRetry(options),
+                });
+            }
+        }
+        /**
+         * @private
+         */
+        async isHistoryComplete() {
+            // We consider that if we have the collection creation event part of the
+            // history, then all records change events have been tracked.
+            const { data: [oldestHistoryEntry], } = await this.bucket.listHistory({
+                limit: 1,
+                filters: {
+                    action: "create",
+                    resource_name: "collection",
+                    collection_id: this.name,
+                },
+            });
+            return !!oldestHistoryEntry;
+        }
+        /**
+         * @private
+         */
+        async listChangesBackTo(at) {
+            // Ensure we have enough history data to retrieve the complete list of
+            // changes.
+            if (!(await this.isHistoryComplete())) {
+                throw new Error("Computing a snapshot is only possible when the full history for a " +
+                    "collection is available. Here, the history plugin seems to have " +
+                    "been enabled after the creation of the collection.");
+            }
+            const { data: changes } = await this.bucket.listHistory({
+                pages: Infinity,
+                sort: "-target.data.last_modified",
+                filters: {
+                    resource_name: "record",
+                    collection_id: this.name,
+                    "max_target.data.last_modified": String(at),
+                },
+            });
+            return changes;
+        }
+        /**
+         * @private
+         */
+        async getSnapshot(at) {
+            if (!at || !Number.isInteger(at) || at <= 0) {
+                throw new Error("Invalid argument, expected a positive integer.");
+            }
+            // Retrieve history and check it covers the required time range.
+            const changes = await this.listChangesBackTo(at);
+            // Replay changes to compute the requested snapshot.
+            const seenIds = new Set();
+            let snapshot = [];
+            for (const { action, target: { data: record }, } of changes) {
+                if (action == "delete") {
+                    seenIds.add(record.id); // ensure not reprocessing deleted entries
+                    snapshot = snapshot.filter((r) => r.id !== record.id);
+                }
+                else if (!seenIds.has(record.id)) {
+                    seenIds.add(record.id);
+                    snapshot.push(record);
+                }
+            }
+            return {
+                last_modified: String(at),
+                data: snapshot.sort((a, b) => b.last_modified - a.last_modified),
+                next: () => {
+                    throw new Error("Snapshots don't support pagination");
+                },
+                hasNextPage: false,
+                totalRecords: snapshot.length,
+            };
+        }
+        /**
+         * Performs batch operations at the current collection level.
+         *
+         * @param  {Function} fn                   The batch operation function.
+         * @param  {Object}   [options={}]         The options object.
+         * @param  {Object}   [options.headers]    The headers object option.
+         * @param  {Boolean}  [options.safe]       The safe option.
+         * @param  {Number}   [options.retry]      The retry option.
+         * @param  {Boolean}  [options.aggregate]  Produces a grouped result object.
+         * @return {Promise<Object, Error>}
+         */
+        async batch(fn, options = {}) {
+            return this.client.batch(fn, {
+                bucket: this.bucket.name,
+                collection: this.name,
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+                safe: this._getSafe(options),
+                aggregate: !!options.aggregate,
+            });
+        }
+    }
+    __decorate([
+        capable(["attachments"])
+    ], Collection.prototype, "addAttachment", null);
+    __decorate([
+        capable(["attachments"])
+    ], Collection.prototype, "removeAttachment", null);
+    __decorate([
+        capable(["history"])
+    ], Collection.prototype, "getSnapshot", null);
+
+    /**
+     * Abstract representation of a selected bucket.
+     *
+     */
+    class Bucket {
+        /**
+         * Constructor.
+         *
+         * @param  {KintoClient} client            The client instance.
+         * @param  {String}      name              The bucket name.
+         * @param  {Object}      [options={}]      The headers object option.
+         * @param  {Object}      [options.headers] The headers object option.
+         * @param  {Boolean}     [options.safe]    The safe option.
+         * @param  {Number}      [options.retry]   The retry option.
+         */
+        constructor(client, name, options = {}) {
+            /**
+             * @ignore
+             */
+            this.client = client;
+            /**
+             * The bucket name.
+             * @type {String}
+             */
+            this.name = name;
+            this._endpoints = client.endpoints;
+            /**
+             * @ignore
+             */
+            this._headers = options.headers || {};
+            this._retry = options.retry || 0;
+            this._safe = !!options.safe;
+        }
+        get execute() {
+            return this.client.execute.bind(this.client);
+        }
+        get headers() {
+            return this._headers;
+        }
+        /**
+         * Get the value of "headers" for a given request, merging the
+         * per-request headers with our own "default" headers.
+         *
+         * @private
+         */
+        _getHeaders(options) {
+            return Object.assign(Object.assign({}, this._headers), options.headers);
+        }
+        /**
+         * Get the value of "safe" for a given request, using the
+         * per-request option if present or falling back to our default
+         * otherwise.
+         *
+         * @private
+         * @param {Object} options The options for a request.
+         * @returns {Boolean}
+         */
+        _getSafe(options) {
+            return Object.assign({ safe: this._safe }, options).safe;
+        }
+        /**
+         * As _getSafe, but for "retry".
+         *
+         * @private
+         */
+        _getRetry(options) {
+            return Object.assign({ retry: this._retry }, options).retry;
+        }
+        /**
+         * Selects a collection.
+         *
+         * @param  {String}  name              The collection name.
+         * @param  {Object}  [options={}]      The options object.
+         * @param  {Object}  [options.headers] The headers object option.
+         * @param  {Boolean} [options.safe]    The safe option.
+         * @return {Collection}
+         */
+        collection(name, options = {}) {
+            return new Collection(this.client, this, name, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+                safe: this._getSafe(options),
+            });
+        }
+        /**
+         * Retrieves the ETag of the collection list, for use with the `since` filtering option.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<String, Error>}
+         */
+        async getCollectionsTimestamp(options = {}) {
+            const path = this._endpoints.collection(this.name);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+                method: "HEAD",
+            };
+            const { headers } = (await this.client.execute(request, {
+                raw: true,
+                retry: this._getRetry(options),
+            }));
+            return headers.get("ETag");
+        }
+        /**
+         * Retrieves the ETag of the group list, for use with the `since` filtering option.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<String, Error>}
+         */
+        async getGroupsTimestamp(options = {}) {
+            const path = this._endpoints.group(this.name);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+                method: "HEAD",
+            };
+            const { headers } = (await this.client.execute(request, {
+                raw: true,
+                retry: this._getRetry(options),
+            }));
+            return headers.get("ETag");
+        }
+        /**
+         * Retrieves bucket data.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Object} [options.query]   Query parameters to pass in
+         *     the request. This might be useful for features that aren't
+         *     yet supported by this library.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async getData(options = {}) {
+            const path = this._endpoints.bucket(this.name);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+            };
+            const { data } = (await this.client.execute(request, {
+                retry: this._getRetry(options),
+                query: options.query,
+                fields: options.fields,
+            }));
+            return data;
+        }
+        /**
+         * Set bucket data.
+         * @param  {Object}  data                    The bucket data object.
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Object}  [options.headers={}]    The headers object option.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean} [options.patch]         The patch option.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async setData(data, options = {}) {
+            if (!isObject(data)) {
+                throw new Error("A bucket object is required.");
+            }
+            const bucket = Object.assign(Object.assign({}, data), { id: this.name });
+            // For default bucket, we need to drop the id from the data object.
+            // Bug in Kinto < 3.1.1
+            const bucketId = bucket.id;
+            if (bucket.id === "default") {
+                delete bucket.id;
+            }
+            const path = this._endpoints.bucket(bucketId);
+            const { patch, permissions } = options;
+            const { last_modified } = Object.assign(Object.assign({}, data), options);
+            const request = updateRequest(path, { data: bucket, permissions }, {
+                last_modified,
+                patch,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of history entries in the current bucket.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Array<Object>, Error>}
+         */
+        async listHistory(options = {}) {
+            const path = this._endpoints.history(this.name);
+            return this.client.paginatedList(path, options, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of collections in the current bucket.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.filters={}] The filters object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @return {Promise<Array<Object>, Error>}
+         */
+        async listCollections(options = {}) {
+            const path = this._endpoints.collection(this.name);
+            return this.client.paginatedList(path, options, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Creates a new collection in current bucket.
+         *
+         * @param  {String|undefined}  id          The collection id.
+         * @param  {Object}  [options={}]          The options object.
+         * @param  {Boolean} [options.safe]        The safe option.
+         * @param  {Object}  [options.headers]     The headers object option.
+         * @param  {Number}  [options.retry=0]     Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.permissions] The permissions object.
+         * @param  {Object}  [options.data]        The data object.
+         * @return {Promise<Object, Error>}
+         */
+        async createCollection(id, options = {}) {
+            const { permissions, data = {} } = options;
+            data.id = id;
+            const path = this._endpoints.collection(this.name, id);
+            const request = createRequest(path, { data, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Deletes a collection from the current bucket.
+         *
+         * @param  {Object|String} collection              The collection to delete.
+         * @param  {Object}        [options={}]            The options object.
+         * @param  {Object}        [options.headers]       The headers object option.
+         * @param  {Number}        [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean}       [options.safe]          The safe option.
+         * @param  {Number}        [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async deleteCollection(collection, options = {}) {
+            const collectionObj = toDataBody(collection);
+            if (!collectionObj.id) {
+                throw new Error("A collection id is required.");
+            }
+            const { id } = collectionObj;
+            const { last_modified } = Object.assign(Object.assign({}, collectionObj), options);
+            const path = this._endpoints.collection(this.name, id);
+            const request = deleteRequest(path, {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of groups in the current bucket.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.filters={}] The filters object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @return {Promise<Array<Object>, Error>}
+         */
+        async listGroups(options = {}) {
+            const path = this._endpoints.group(this.name);
+            return this.client.paginatedList(path, options, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Fetches a group in current bucket.
+         *
+         * @param  {String} id                The group id.
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object} [options.query]   Query parameters to pass in
+         *     the request. This might be useful for features that aren't
+         *     yet supported by this library.
+         * @param  {Array}  [options.fields]  Limit response to
+         *     just some fields.
+         * @return {Promise<Object, Error>}
+         */
+        async getGroup(id, options = {}) {
+            const path = this._endpoints.group(this.name, id);
+            const request = {
+                headers: this._getHeaders(options),
+                path,
+            };
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+                query: options.query,
+                fields: options.fields,
+            });
+        }
+        /**
+         * Creates a new group in current bucket.
+         *
+         * @param  {String|undefined}  id                    The group id.
+         * @param  {Array<String>}     [members=[]]          The list of principals.
+         * @param  {Object}            [options={}]          The options object.
+         * @param  {Object}            [options.data]        The data object.
+         * @param  {Object}            [options.permissions] The permissions object.
+         * @param  {Boolean}           [options.safe]        The safe option.
+         * @param  {Object}            [options.headers]     The headers object option.
+         * @param  {Number}            [options.retry=0]     Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async createGroup(id, members = [], options = {}) {
+            const data = Object.assign(Object.assign({}, options.data), { id,
+                members });
+            const path = this._endpoints.group(this.name, id);
+            const { permissions } = options;
+            const request = createRequest(path, { data, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Updates an existing group in current bucket.
+         *
+         * @param  {Object}  group                   The group object.
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Object}  [options.data]          The data object.
+         * @param  {Object}  [options.permissions]   The permissions object.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async updateGroup(group, options = {}) {
+            if (!isObject(group)) {
+                throw new Error("A group object is required.");
+            }
+            if (!group.id) {
+                throw new Error("A group id is required.");
+            }
+            const data = Object.assign(Object.assign({}, options.data), group);
+            const path = this._endpoints.group(this.name, group.id);
+            const { patch, permissions } = options;
+            const { last_modified } = Object.assign(Object.assign({}, data), options);
+            const request = updateRequest(path, { data, permissions }, {
+                last_modified,
+                patch,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Deletes a group from the current bucket.
+         *
+         * @param  {Object|String} group                   The group to delete.
+         * @param  {Object}        [options={}]            The options object.
+         * @param  {Object}        [options.headers]       The headers object option.
+         * @param  {Number}        [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Boolean}       [options.safe]          The safe option.
+         * @param  {Number}        [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async deleteGroup(group, options = {}) {
+            const groupObj = toDataBody(group);
+            const { id } = groupObj;
+            const { last_modified } = Object.assign(Object.assign({}, groupObj), options);
+            const path = this._endpoints.group(this.name, id);
+            const request = deleteRequest(path, {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of permissions for this bucket.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers] The headers object option.
+         * @param  {Number} [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async getPermissions(options = {}) {
+            const request = {
+                headers: this._getHeaders(options),
+                path: this._endpoints.bucket(this.name),
+            };
+            const { permissions } = (await this.client.execute(request, {
+                retry: this._getRetry(options),
+            }));
+            return permissions;
+        }
+        /**
+         * Replaces all existing bucket permissions with the ones provided.
+         *
+         * @param  {Object}  permissions             The permissions object.
+         * @param  {Object}  [options={}]            The options object
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers={}]    The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async setPermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.bucket(this.name);
+            const { last_modified } = options;
+            const data = { last_modified };
+            const request = updateRequest(path, { data, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Append principals to the bucket permissions.
+         *
+         * @param  {Object}  permissions             The permissions object.
+         * @param  {Object}  [options={}]            The options object
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async addPermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.bucket(this.name);
+            const { last_modified } = options;
+            const request = jsonPatchPermissionsRequest(path, permissions, "add", {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Remove principals from the bucket permissions.
+         *
+         * @param  {Object}  permissions             The permissions object.
+         * @param  {Object}  [options={}]            The options object
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async removePermissions(permissions, options = {}) {
+            if (!isObject(permissions)) {
+                throw new Error("A permissions object is required.");
+            }
+            const path = this._endpoints.bucket(this.name);
+            const { last_modified } = options;
+            const request = jsonPatchPermissionsRequest(path, permissions, "remove", {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            });
+            return this.client.execute(request, {
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Performs batch operations at the current bucket level.
+         *
+         * @param  {Function} fn                   The batch operation function.
+         * @param  {Object}   [options={}]         The options object.
+         * @param  {Object}   [options.headers]    The headers object option.
+         * @param  {Boolean}  [options.safe]       The safe option.
+         * @param  {Number}   [options.retry=0]    The retry option.
+         * @param  {Boolean}  [options.aggregate]  Produces a grouped result object.
+         * @return {Promise<Object, Error>}
+         */
+        async batch(fn, options = {}) {
+            return this.client.batch(fn, {
+                bucket: this.name,
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+                safe: this._getSafe(options),
+                aggregate: !!options.aggregate,
+            });
+        }
+    }
+    __decorate([
+        capable(["history"])
+    ], Bucket.prototype, "listHistory", null);
+
+    /**
+     * Currently supported protocol version.
+     * @type {String}
+     */
+    const SUPPORTED_PROTOCOL_VERSION = "v1";
+    /**
+     * High level HTTP client for the Kinto API.
+     *
+     * @example
+     * const client = new KintoClient("https://kinto.dev.mozaws.net/v1");
+     * client.bucket("default")
+     *    .collection("my-blog")
+     *    .createRecord({title: "First article"})
+     *   .then(console.log.bind(console))
+     *   .catch(console.error.bind(console));
+     */
+    class KintoClientBase {
+        /**
+         * Constructor.
+         *
+         * @param  {String}       remote  The remote URL.
+         * @param  {Object}       [options={}]                  The options object.
+         * @param  {Boolean}      [options.safe=true]           Adds concurrency headers to every requests.
+         * @param  {EventEmitter} [options.events=EventEmitter] The events handler instance.
+         * @param  {Object}       [options.headers={}]          The key-value headers to pass to each request.
+         * @param  {Object}       [options.retry=0]             Number of retries when request fails (default: 0)
+         * @param  {String}       [options.bucket="default"]    The default bucket to use.
+         * @param  {String}       [options.requestMode="cors"]  The HTTP request mode (from ES6 fetch spec).
+         * @param  {Number}       [options.timeout=null]        The request timeout in ms, if any.
+         */
+        constructor(remote, options) {
+            if (typeof remote !== "string" || !remote.length) {
+                throw new Error("Invalid remote URL: " + remote);
+            }
+            if (remote[remote.length - 1] === "/") {
+                remote = remote.slice(0, -1);
+            }
+            this._backoffReleaseTime = null;
+            this._requests = [];
+            this._isBatch = !!options.batch;
+            this._retry = options.retry || 0;
+            this._safe = !!options.safe;
+            this._headers = options.headers || {};
+            // public properties
+            /**
+             * The remote server base URL.
+             * @type {String}
+             */
+            this.remote = remote;
+            /**
+             * Current server information.
+             * @ignore
+             * @type {Object|null}
+             */
+            this.serverInfo = null;
+            /**
+             * The event emitter instance. Should comply with the `EventEmitter`
+             * interface.
+             * @ignore
+             * @type {Class}
+             */
+            this.events = options.events;
+            this.endpoints = ENDPOINTS;
+            const { requestMode, timeout } = options;
+            /**
+             * The HTTP instance.
+             * @ignore
+             * @type {HTTP}
+             */
+            this.http = new HTTP(this.events, { requestMode, timeout });
+            this._registerHTTPEvents();
+        }
+        /**
+         * The remote endpoint base URL. Setting the value will also extract and
+         * validate the version.
+         * @type {String}
+         */
+        get remote() {
+            return this._remote;
+        }
+        /**
+         * @ignore
+         */
+        set remote(url) {
+            let version;
+            try {
+                version = url.match(/\/(v\d+)\/?$/)[1];
+            }
+            catch (err) {
+                throw new Error("The remote URL must contain the version: " + url);
+            }
+            if (version !== SUPPORTED_PROTOCOL_VERSION) {
+                throw new Error(`Unsupported protocol version: ${version}`);
+            }
+            this._remote = url;
+            this._version = version;
+        }
+        /**
+         * The current server protocol version, eg. `v1`.
+         * @type {String}
+         */
+        get version() {
+            return this._version;
+        }
+        /**
+         * Backoff remaining time, in milliseconds. Defaults to zero if no backoff is
+         * ongoing.
+         *
+         * @type {Number}
+         */
+        get backoff() {
+            const currentTime = new Date().getTime();
+            if (this._backoffReleaseTime && currentTime < this._backoffReleaseTime) {
+                return this._backoffReleaseTime - currentTime;
+            }
+            return 0;
+        }
+        /**
+         * Registers HTTP events.
+         * @private
+         */
+        _registerHTTPEvents() {
+            // Prevent registering event from a batch client instance
+            if (!this._isBatch && this.events) {
+                this.events.on("backoff", (backoffMs) => {
+                    this._backoffReleaseTime = backoffMs;
+                });
+            }
+        }
+        /**
+         * Retrieve a bucket object to perform operations on it.
+         *
+         * @param  {String}  name              The bucket name.
+         * @param  {Object}  [options={}]      The request options.
+         * @param  {Boolean} [options.safe]    The resulting safe option.
+         * @param  {Number}  [options.retry]   The resulting retry option.
+         * @param  {Object}  [options.headers] The extended headers object option.
+         * @return {Bucket}
+         */
+        bucket(name, options = {}) {
+            return new Bucket(this, name, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Set client "headers" for every request, updating previous headers (if any).
+         *
+         * @param {Object} headers The headers to merge with existing ones.
+         */
+        setHeaders(headers) {
+            this._headers = Object.assign(Object.assign({}, this._headers), headers);
+            this.serverInfo = null;
+        }
+        /**
+         * Get the value of "headers" for a given request, merging the
+         * per-request headers with our own "default" headers.
+         *
+         * Note that unlike other options, headers aren't overridden, but
+         * merged instead.
+         *
+         * @private
+         * @param {Object} options The options for a request.
+         * @returns {Object}
+         */
+        _getHeaders(options) {
+            return Object.assign(Object.assign({}, this._headers), options.headers);
+        }
+        /**
+         * Get the value of "safe" for a given request, using the
+         * per-request option if present or falling back to our default
+         * otherwise.
+         *
+         * @private
+         * @param {Object} options The options for a request.
+         * @returns {Boolean}
+         */
+        _getSafe(options) {
+            return Object.assign({ safe: this._safe }, options).safe;
+        }
+        /**
+         * As _getSafe, but for "retry".
+         *
+         * @private
+         */
+        _getRetry(options) {
+            return Object.assign({ retry: this._retry }, options).retry;
+        }
+        /**
+         * Retrieves the server's "hello" endpoint. This endpoint reveals
+         * server capabilities and settings as well as telling the client
+         * "who they are" according to their given authorization headers.
+         *
+         * @private
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Object}  [options.headers={}] Headers to use when making
+         *     this request.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async _getHello(options = {}) {
+            const path = this.remote + ENDPOINTS.root();
+            const { json } = await this.http.request(path, { headers: this._getHeaders(options) }, { retry: this._getRetry(options) });
+            return json;
+        }
+        /**
+         * Retrieves server information and persist them locally. This operation is
+         * usually performed a single time during the instance lifecycle.
+         *
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async fetchServerInfo(options = {}) {
+            if (this.serverInfo) {
+                return this.serverInfo;
+            }
+            this.serverInfo = await this._getHello({ retry: this._getRetry(options) });
+            return this.serverInfo;
+        }
+        /**
+         * Retrieves Kinto server settings.
+         *
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async fetchServerSettings(options = {}) {
+            const { settings } = await this.fetchServerInfo(options);
+            return settings;
+        }
+        /**
+         * Retrieve server capabilities information.
+         *
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async fetchServerCapabilities(options = {}) {
+            const { capabilities } = await this.fetchServerInfo(options);
+            return capabilities;
+        }
+        /**
+         * Retrieve authenticated user information.
+         *
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Object}  [options.headers={}] Headers to use when making
+         *     this request.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async fetchUser(options = {}) {
+            const { user } = await this._getHello(options);
+            return user;
+        }
+        /**
+         * Retrieve authenticated user information.
+         *
+         * @param  {Object}  [options={}] The request options.
+         * @param  {Number}  [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async fetchHTTPApiVersion(options = {}) {
+            const { http_api_version } = await this.fetchServerInfo(options);
+            return http_api_version;
+        }
+        /**
+         * Process batch requests, chunking them according to the batch_max_requests
+         * server setting when needed.
+         *
+         * @param  {Array}  requests     The list of batch subrequests to perform.
+         * @param  {Object} [options={}] The options object.
+         * @return {Promise<Object, Error>}
+         */
+        async _batchRequests(requests, options = {}) {
+            const headers = this._getHeaders(options);
+            if (!requests.length) {
+                return [];
+            }
+            const serverSettings = await this.fetchServerSettings({
+                retry: this._getRetry(options),
+            });
+            const maxRequests = serverSettings["batch_max_requests"];
+            if (maxRequests && requests.length > maxRequests) {
+                const chunks = partition(requests, maxRequests);
+                const results = [];
+                for (const chunk of chunks) {
+                    const result = await this._batchRequests(chunk, options);
+                    results.push(...result);
+                }
+                return results;
+            }
+            const { responses } = (await this.execute({
+                // FIXME: is this really necessary, since it's also present in
+                // the "defaults"?
+                headers,
+                path: ENDPOINTS.batch(),
+                method: "POST",
+                body: {
+                    defaults: { headers },
+                    requests,
+                },
+            }, { retry: this._getRetry(options) }));
+            return responses;
+        }
+        /**
+         * Sends batch requests to the remote server.
+         *
+         * Note: Reserved for internal use only.
+         *
+         * @ignore
+         * @param  {Function} fn                        The function to use for describing batch ops.
+         * @param  {Object}   [options={}]              The options object.
+         * @param  {Boolean}  [options.safe]            The safe option.
+         * @param  {Number}   [options.retry]           The retry option.
+         * @param  {String}   [options.bucket]          The bucket name option.
+         * @param  {String}   [options.collection]      The collection name option.
+         * @param  {Object}   [options.headers]         The headers object option.
+         * @param  {Boolean}  [options.aggregate=false] Produces an aggregated result object.
+         * @return {Promise<Object, Error>}
+         */
+        async batch(fn, options = {}) {
+            const rootBatch = new KintoClientBase(this.remote, {
+                events: this.events,
+                batch: true,
+                safe: this._getSafe(options),
+                retry: this._getRetry(options),
+            });
+            if (options.bucket && options.collection) {
+                fn(rootBatch.bucket(options.bucket).collection(options.collection));
+            }
+            else if (options.bucket) {
+                fn(rootBatch.bucket(options.bucket));
+            }
+            else {
+                fn(rootBatch);
+            }
+            const responses = await this._batchRequests(rootBatch._requests, options);
+            if (options.aggregate) {
+                return aggregate(responses, rootBatch._requests);
+            }
+            else {
+                return responses;
+            }
+        }
+        /**
+         * Executes an atomic HTTP request.
+         *
+         * @param  {Object}  request             The request object.
+         * @param  {String}  request.path        The path to fetch, relative
+         *     to the Kinto server root.
+         * @param  {String}  [request.method="GET"] The method to use in the
+         *     request.
+         * @param  {Body}    [request.body]      The request body.
+         * @param  {Object}  [request.headers={}] The request headers.
+         * @param  {Object}  [options={}]        The options object.
+         * @param  {Boolean} [options.raw=false] If true, resolve with full response
+         * @param  {Boolean} [options.stringify=true] If true, serialize body data to
+         * @param  {Number}  [options.retry=0]   The number of times to
+         *     retry a request if the server responds with Retry-After.
+         * JSON.
+         * @return {Promise<Object, Error>}
+         */
+        async execute(request, options = {}) {
+            const { raw = false, stringify = true } = options;
+            // If we're within a batch, add the request to the stack to send at once.
+            if (this._isBatch) {
+                this._requests.push(request);
+                // Resolve with a message in case people attempt at consuming the result
+                // from within a batch operation.
+                const msg = ("This result is generated from within a batch " +
+                    "operation and should not be consumed.");
+                return raw
+                    ? { status: 0, json: msg, headers: new Headers() }
+                    : msg;
+            }
+            const uri = this.remote + addEndpointOptions(request.path, options);
+            const result = await this.http.request(uri, cleanUndefinedProperties({
+                // Limit requests to only those parts that would be allowed in
+                // a batch request -- don't pass through other fancy fetch()
+                // options like integrity, redirect, mode because they will
+                // break on a batch request.  A batch request only allows
+                // headers, method, path (above), and body.
+                method: request.method,
+                headers: request.headers,
+                body: stringify ? JSON.stringify(request.body) : request.body,
+            }), { retry: this._getRetry(options) });
+            return raw ? result : result.json;
+        }
+        /**
+         * Fetch some pages from a paginated list, following the `next-page`
+         * header automatically until we have fetched the requested number
+         * of pages. Return a response with a `.next()` method that can be
+         * called to fetch more results.
+         *
+         * @private
+         * @param  {String}  path
+         *     The path to make the request to.
+         * @param  {Object}  params
+         *     The parameters to use when making the request.
+         * @param  {String}  [params.sort="-last_modified"]
+         *     The sorting order to use when fetching.
+         * @param  {Object}  [params.filters={}]
+         *     The filters to send in the request.
+         * @param  {Number}  [params.limit=undefined]
+         *     The limit to send in the request. Undefined means no limit.
+         * @param  {Number}  [params.pages=undefined]
+         *     The number of pages to fetch. Undefined means one page. Pass
+         *     Infinity to fetch everything.
+         * @param  {String}  [params.since=undefined]
+         *     The ETag from which to start fetching.
+         * @param  {Array}   [params.fields]
+         *     Limit response to just some fields.
+         * @param  {Object}  [options={}]
+         *     Additional request-level parameters to use in all requests.
+         * @param  {Object}  [options.headers={}]
+         *     Headers to use during all requests.
+         * @param  {Number}  [options.retry=0]
+         *     Number of times to retry each request if the server responds
+         *     with Retry-After.
+         */
+        async paginatedList(path, params = {}, options = {}) {
+            // FIXME: this is called even in batch requests, which doesn't
+            // make any sense (since all batch requests get a "dummy"
+            // response; see execute() above).
+            const { sort, filters, limit, pages, since, fields } = Object.assign({ sort: "-last_modified" }, params);
+            // Safety/Consistency check on ETag value.
+            if (since && typeof since !== "string") {
+                throw new Error(`Invalid value for since (${since}), should be ETag value.`);
+            }
+            const query = Object.assign(Object.assign({}, filters), { _sort: sort, _limit: limit, _since: since });
+            if (fields) {
+                query._fields = fields;
+            }
+            const querystring = qsify(query);
+            let results = [], current = 0;
+            const next = async function (nextPage) {
+                if (!nextPage) {
+                    throw new Error("Pagination exhausted.");
+                }
+                return processNextPage(nextPage);
+            };
+            const processNextPage = async (nextPage) => {
+                const { headers } = options;
+                return handleResponse(await this.http.request(nextPage, { headers }));
+            };
+            const pageResults = (results, nextPage, etag) => {
+                // ETag string is supposed to be opaque and stored «as-is».
+                // ETag header values are quoted (because of * and W/"foo").
+                return {
+                    last_modified: etag ? etag.replace(/"/g, "") : etag,
+                    data: results,
+                    next: next.bind(null, nextPage),
+                    hasNextPage: !!nextPage,
+                    totalRecords: -1,
+                };
+            };
+            const handleResponse = async function ({ headers, json, }) {
+                const nextPage = headers.get("Next-Page");
+                const etag = headers.get("ETag");
+                if (!pages) {
+                    return pageResults(json.data, nextPage, etag);
+                }
+                // Aggregate new results with previous ones
+                results = results.concat(json.data);
+                current += 1;
+                if (current >= pages || !nextPage) {
+                    // Pagination exhausted
+                    return pageResults(results, nextPage, etag);
+                }
+                // Follow next page
+                return processNextPage(nextPage);
+            };
+            return handleResponse((await this.execute(
+            // N.B.: This doesn't use _getHeaders, because all calls to
+            // `paginatedList` are assumed to come from calls that already
+            // have headers merged at e.g. the bucket or collection level.
+            {
+                headers: options.headers ? options.headers : {},
+                path: path + "?" + querystring,
+            },
+            // N.B. This doesn't use _getRetry, because all calls to
+            // `paginatedList` are assumed to come from calls that already
+            // used `_getRetry` at e.g. the bucket or collection level.
+            { raw: true, retry: options.retry || 0 })));
+        }
+        /**
+         * Lists all permissions.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers={}] Headers to use when making
+         *     this request.
+         * @param  {Number} [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object[], Error>}
+         */
+        async listPermissions(options = {}) {
+            const path = ENDPOINTS.permissions();
+            // Ensure the default sort parameter is something that exists in permissions
+            // entries, as `last_modified` doesn't; here, we pick "id".
+            const paginationOptions = Object.assign({ sort: "id" }, options);
+            return this.paginatedList(path, paginationOptions, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Retrieves the list of buckets.
+         *
+         * @param  {Object} [options={}]      The options object.
+         * @param  {Object} [options.headers={}] Headers to use when making
+         *     this request.
+         * @param  {Number} [options.retry=0]    Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Object} [options.filters={}] The filters object.
+         * @param  {Array}  [options.fields]     Limit response to
+         *     just some fields.
+         * @return {Promise<Object[], Error>}
+         */
+        async listBuckets(options = {}) {
+            const path = ENDPOINTS.bucket();
+            return this.paginatedList(path, options, {
+                headers: this._getHeaders(options),
+                retry: this._getRetry(options),
+            });
+        }
+        /**
+         * Creates a new bucket on the server.
+         *
+         * @param  {String|null}  id                The bucket name (optional).
+         * @param  {Object}       [options={}]      The options object.
+         * @param  {Boolean}      [options.data]    The bucket data option.
+         * @param  {Boolean}      [options.safe]    The safe option.
+         * @param  {Object}       [options.headers] The headers object option.
+         * @param  {Number}       [options.retry=0] Number of retries to make
+         *     when faced with transient errors.
+         * @return {Promise<Object, Error>}
+         */
+        async createBucket(id, options = {}) {
+            const { data, permissions } = options;
+            const _data = Object.assign(Object.assign({}, data), { id: id ? id : undefined });
+            const path = _data.id ? ENDPOINTS.bucket(_data.id) : ENDPOINTS.bucket();
+            return this.execute(createRequest(path, { data: _data, permissions }, {
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            }), { retry: this._getRetry(options) });
+        }
+        /**
+         * Deletes a bucket from the server.
+         *
+         * @ignore
+         * @param  {Object|String} bucket                  The bucket to delete.
+         * @param  {Object}        [options={}]            The options object.
+         * @param  {Boolean}       [options.safe]          The safe option.
+         * @param  {Object}        [options.headers]       The headers object option.
+         * @param  {Number}        [options.retry=0]       Number of retries to make
+         *     when faced with transient errors.
+         * @param  {Number}        [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async deleteBucket(bucket, options = {}) {
+            const bucketObj = toDataBody(bucket);
+            if (!bucketObj.id) {
+                throw new Error("A bucket id is required.");
+            }
+            const path = ENDPOINTS.bucket(bucketObj.id);
+            const { last_modified } = Object.assign(Object.assign({}, bucketObj), options);
+            return this.execute(deleteRequest(path, {
+                last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            }), { retry: this._getRetry(options) });
+        }
+        /**
+         * Deletes all buckets on the server.
+         *
+         * @ignore
+         * @param  {Object}  [options={}]            The options object.
+         * @param  {Boolean} [options.safe]          The safe option.
+         * @param  {Object}  [options.headers]       The headers object option.
+         * @param  {Number}  [options.last_modified] The last_modified option.
+         * @return {Promise<Object, Error>}
+         */
+        async deleteBuckets(options = {}) {
+            const path = ENDPOINTS.bucket();
+            return this.execute(deleteRequest(path, {
+                last_modified: options.last_modified,
+                headers: this._getHeaders(options),
+                safe: this._getSafe(options),
+            }), { retry: this._getRetry(options) });
+        }
+        async createAccount(username, password) {
+            return this.execute(createRequest(`/accounts/${username}`, { data: { password } }, { method: "PUT" }));
+        }
+    }
+    __decorate([
+        nobatch("This operation is not supported within a batch operation.")
+    ], KintoClientBase.prototype, "fetchServerSettings", null);
+    __decorate([
+        nobatch("This operation is not supported within a batch operation.")
+    ], KintoClientBase.prototype, "fetchServerCapabilities", null);
+    __decorate([
+        nobatch("This operation is not supported within a batch operation.")
+    ], KintoClientBase.prototype, "fetchUser", null);
+    __decorate([
+        nobatch("This operation is not supported within a batch operation.")
+    ], KintoClientBase.prototype, "fetchHTTPApiVersion", null);
+    __decorate([
+        nobatch("Can't use batch within a batch!")
+    ], KintoClientBase.prototype, "batch", null);
+    __decorate([
+        capable(["permissions_endpoint"])
+    ], KintoClientBase.prototype, "listPermissions", null);
+    __decorate([
+        support("1.4", "2.0")
+    ], KintoClientBase.prototype, "deleteBuckets", null);
+    __decorate([
+        capable(["accounts"])
+    ], KintoClientBase.prototype, "createAccount", null);
+
+    /*
+     *
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *
+     *     http://www.apache.org/licenses/LICENSE-2.0
+     *
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    const { EventEmitter } = ChromeUtils.import("resource://gre/modules/EventEmitter.jsm");
+    class KintoHttpClient extends KintoClientBase {
+        constructor(remote, options = {}) {
+            const events = {};
+            EventEmitter.decorate(events);
+            super(remote, Object.assign({ events: events }, options));
+        }
+    }
+    KintoHttpClient.errors = errors;
+
+    return KintoHttpClient;
+
+})));