aboutsummaryrefslogtreecommitdiff
path: root/ext/lib/dexie-export-import.js
diff options
context:
space:
mode:
Diffstat (limited to 'ext/lib/dexie-export-import.js')
-rw-r--r--ext/lib/dexie-export-import.js3457
1 files changed, 3457 insertions, 0 deletions
diff --git a/ext/lib/dexie-export-import.js b/ext/lib/dexie-export-import.js
new file mode 100644
index 00000000..f915d1c1
--- /dev/null
+++ b/ext/lib/dexie-export-import.js
@@ -0,0 +1,3457 @@
+/* ==========================================================================
+ * dexie-export-import.js
+ * ==========================================================================
+ *
+ * Dexie addon for exporting and importing databases to / from Blobs.
+ *
+ * By David Fahlander, david.fahlander@gmail.com,
+ *
+ * ==========================================================================
+ *
+ * Version 4.0.7, Wed Mar 29 2023
+ *
+ * https://dexie.org
+ *
+ * Apache License Version 2.0, January 2004, http://www.apache.org/licenses/
+ *
+ */
+
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('dexie')) :
+ typeof define === 'function' && define.amd ? define(['exports', 'dexie'], factory) :
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.DexieExportImport = {}, global.Dexie));
+})(this, (function (exports, Dexie) { 'use strict';
+
+ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+ var Dexie__default = /*#__PURE__*/_interopDefaultLegacy(Dexie);
+
+ /*! *****************************************************************************
+ Copyright (c) Microsoft Corporation.
+
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ PERFORMANCE OF THIS SOFTWARE.
+ ***************************************************************************** */
+
+ function __awaiter(thisArg, _arguments, P, generator) {
+ function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ }
+
+ function __generator(thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [op[0] & 2, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+ }
+
+ function getSchemaString(table) {
+ var primKeyAndIndexes = [table.schema.primKey].concat(table.schema.indexes);
+ return primKeyAndIndexes.map(function (index) { return index.src; }).join(',');
+ }
+ function extractDbSchema(exportedDb) {
+ var schema = {};
+ for (var _i = 0, _a = exportedDb.tables; _i < _a.length; _i++) {
+ var table = _a[_i];
+ schema[table.name] = table.schema;
+ }
+ return schema;
+ }
+ function readBlobAsync(blob, type) {
+ return new Promise(function (resolve, reject) {
+ var reader = new FileReader();
+ reader.onabort = function (ev) { return reject(new Error("file read aborted")); };
+ reader.onerror = function (ev) { return reject(ev.target.error); };
+ reader.onload = function (ev) { return resolve(ev.target.result); };
+ if (type === 'binary')
+ reader.readAsArrayBuffer(blob);
+ else
+ reader.readAsText(blob);
+ });
+ }
+ function readBlobSync(blob, type) {
+ if (typeof FileReaderSync === 'undefined') {
+ throw new Error('FileReaderSync missing. Reading blobs synchronously requires code to run from within a web worker. Use TSON.encapsulateAsync() to do it from the main thread.');
+ }
+ var reader = new FileReaderSync(); // Requires worker environment
+ var data = type === 'binary' ?
+ reader.readAsArrayBuffer(blob) :
+ reader.readAsText(blob);
+ return data;
+ }
+
+ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+ function createCommonjsModule(fn, module) {
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
+ }
+
+ var typeson = createCommonjsModule(function (module, exports) {
+ (function (global, factory) {
+ module.exports = factory() ;
+ }(commonjsGlobal, (function () {
+ function _typeof(obj) {
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof = function (obj) {
+ return typeof obj;
+ };
+ } else {
+ _typeof = function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ };
+ }
+
+ return _typeof(obj);
+ }
+
+ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+ try {
+ var info = gen[key](arg);
+ var value = info.value;
+ } catch (error) {
+ reject(error);
+ return;
+ }
+
+ if (info.done) {
+ resolve(value);
+ } else {
+ Promise.resolve(value).then(_next, _throw);
+ }
+ }
+
+ function _asyncToGenerator(fn) {
+ return function () {
+ var self = this,
+ args = arguments;
+ return new Promise(function (resolve, reject) {
+ var gen = fn.apply(self, args);
+
+ function _next(value) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+ }
+
+ function _throw(err) {
+ asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+ }
+
+ _next(undefined);
+ });
+ };
+ }
+
+ function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+
+ function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+
+ function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ function ownKeys(object, enumerableOnly) {
+ var keys = Object.keys(object);
+
+ if (Object.getOwnPropertySymbols) {
+ var symbols = Object.getOwnPropertySymbols(object);
+ if (enumerableOnly) symbols = symbols.filter(function (sym) {
+ return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+ });
+ keys.push.apply(keys, symbols);
+ }
+
+ return keys;
+ }
+
+ function _objectSpread2(target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i] != null ? arguments[i] : {};
+
+ if (i % 2) {
+ ownKeys(Object(source), true).forEach(function (key) {
+ _defineProperty(target, key, source[key]);
+ });
+ } else if (Object.getOwnPropertyDescriptors) {
+ Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+ } else {
+ ownKeys(Object(source)).forEach(function (key) {
+ Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+ });
+ }
+ }
+
+ return target;
+ }
+
+ function _slicedToArray(arr, i) {
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+ }
+
+ function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+ }
+
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) {
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
+
+ return arr2;
+ }
+ }
+
+ function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+ }
+
+ function _iterableToArray(iter) {
+ if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+ }
+
+ function _iterableToArrayLimit(arr, i) {
+ if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
+ return;
+ }
+
+ var _arr = [];
+ var _n = true;
+ var _d = false;
+ var _e = undefined;
+
+ try {
+ for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+ _arr.push(_s.value);
+
+ if (i && _arr.length === i) break;
+ }
+ } catch (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null) _i["return"]();
+ } finally {
+ if (_d) throw _e;
+ }
+ }
+
+ return _arr;
+ }
+
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }
+
+ function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
+ }
+
+ /**
+ * We keep this function minimized so if using two instances of this
+ * library, where one is minimized and one is not, it will still work
+ * with `hasConstructorOf`.
+ * With ES6 classes, we may be able to simply use `class TypesonPromise
+ * extends Promise` and add a string tag for detection.
+ * @param {function} f
+ */
+ // eslint-disable-next-line max-len
+ // eslint-disable-next-line block-spacing, space-before-function-paren, space-before-blocks, space-infix-ops, semi, promise/avoid-new
+ var TypesonPromise = function TypesonPromise(f) {
+ _classCallCheck(this, TypesonPromise);
+
+ this.p = new Promise(f);
+ }; // eslint-disable-next-line max-len
+ // class TypesonPromise extends Promise {get[Symbol.toStringTag](){return 'TypesonPromise'};} // eslint-disable-line keyword-spacing, space-before-function-paren, space-before-blocks, block-spacing, semi
+
+
+ TypesonPromise.__typeson__type__ = 'TypesonPromise'; // Note: core-js-bundle provides a `Symbol` polyfill
+
+ /* istanbul ignore else */
+
+ if (typeof Symbol !== 'undefined') {
+ // Ensure `isUserObject` will return `false` for `TypesonPromise`
+ TypesonPromise.prototype[Symbol.toStringTag] = 'TypesonPromise';
+ }
+ /**
+ *
+ * @param {function} [onFulfilled]
+ * @param {function} [onRejected]
+ * @returns {TypesonPromise}
+ */
+
+
+ TypesonPromise.prototype.then = function (onFulfilled, onRejected) {
+ var _this = this;
+
+ return new TypesonPromise(function (typesonResolve, typesonReject) {
+ // eslint-disable-next-line promise/catch-or-return
+ _this.p.then(function (res) {
+ // eslint-disable-next-line promise/always-return
+ typesonResolve(onFulfilled ? onFulfilled(res) : res);
+ })["catch"](function (res) {
+ return onRejected ? onRejected(res) : Promise.reject(res);
+ }).then(typesonResolve, typesonReject);
+ });
+ };
+ /**
+ *
+ * @param {function} onRejected
+ * @returns {TypesonPromise}
+ */
+
+
+ TypesonPromise.prototype["catch"] = function (onRejected) {
+ return this.then(null, onRejected);
+ };
+ /**
+ *
+ * @param {Any} v
+ * @returns {TypesonPromise}
+ */
+
+
+ TypesonPromise.resolve = function (v) {
+ return new TypesonPromise(function (typesonResolve) {
+ typesonResolve(v);
+ });
+ };
+ /**
+ *
+ * @param {Any} v
+ * @returns {TypesonPromise}
+ */
+
+
+ TypesonPromise.reject = function (v) {
+ return new TypesonPromise(function (typesonResolve, typesonReject) {
+ typesonReject(v);
+ });
+ };
+
+ ['all', 'race'].forEach(function (meth) {
+ /**
+ *
+ * @param {Promise[]} promArr
+ * @returns {TypesonPromise}
+ */
+ TypesonPromise[meth] = function (promArr) {
+ return new TypesonPromise(function (typesonResolve, typesonReject) {
+ // eslint-disable-next-line promise/catch-or-return
+ Promise[meth](promArr.map(function (prom) {
+ return prom && prom.constructor && prom.constructor.__typeson__type__ === 'TypesonPromise' ? prom.p : prom;
+ })).then(typesonResolve, typesonReject);
+ });
+ };
+ });
+
+ var _ref = {},
+ toStr = _ref.toString,
+ hasOwn = {}.hasOwnProperty,
+ getProto = Object.getPrototypeOf,
+ fnToString = hasOwn.toString;
+ /**
+ * Second argument not in use internally, but provided for utility.
+ * @param {Any} v
+ * @param {boolean} catchCheck
+ * @returns {boolean}
+ */
+
+ function isThenable(v, catchCheck) {
+ return isObject(v) && typeof v.then === 'function' && (!catchCheck || typeof v["catch"] === 'function');
+ }
+ /**
+ *
+ * @param {Any} val
+ * @returns {string}
+ */
+
+
+ function toStringTag(val) {
+ return toStr.call(val).slice(8, -1);
+ }
+ /**
+ * This function is dependent on both constructors
+ * being identical so any minimization is expected of both.
+ * @param {Any} a
+ * @param {function} b
+ * @returns {boolean}
+ */
+
+
+ function hasConstructorOf(a, b) {
+ if (!a || _typeof(a) !== 'object') {
+ return false;
+ }
+
+ var proto = getProto(a);
+
+ if (!proto) {
+ return b === null;
+ }
+
+ var Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;
+
+ if (typeof Ctor !== 'function') {
+ return b === null;
+ }
+
+ if (b === Ctor) {
+ return true;
+ }
+
+ if (b !== null && fnToString.call(Ctor) === fnToString.call(b)) {
+ return true;
+ }
+
+ if (typeof b === 'function' && typeof Ctor.__typeson__type__ === 'string' && Ctor.__typeson__type__ === b.__typeson__type__) {
+ return true;
+ }
+
+ return false;
+ }
+ /**
+ *
+ * @param {Any} val
+ * @returns {boolean}
+ */
+
+
+ function isPlainObject(val) {
+ // Mirrors jQuery's
+ if (!val || toStringTag(val) !== 'Object') {
+ return false;
+ }
+
+ var proto = getProto(val);
+
+ if (!proto) {
+ // `Object.create(null)`
+ return true;
+ }
+
+ return hasConstructorOf(val, Object);
+ }
+ /**
+ *
+ * @param {Any} val
+ * @returns {boolean}
+ */
+
+
+ function isUserObject(val) {
+ if (!val || toStringTag(val) !== 'Object') {
+ return false;
+ }
+
+ var proto = getProto(val);
+
+ if (!proto) {
+ // `Object.create(null)`
+ return true;
+ }
+
+ return hasConstructorOf(val, Object) || isUserObject(proto);
+ }
+ /**
+ *
+ * @param {Any} v
+ * @returns {boolean}
+ */
+
+
+ function isObject(v) {
+ return v && _typeof(v) === 'object';
+ }
+ /**
+ *
+ * @param {string} keyPathComponent
+ * @returns {string}
+ */
+
+
+ function escapeKeyPathComponent(keyPathComponent) {
+ return keyPathComponent.replace(/~/g, '~0').replace(/\./g, '~1');
+ }
+ /**
+ *
+ * @param {string} keyPathComponent
+ * @returns {string}
+ */
+
+
+ function unescapeKeyPathComponent(keyPathComponent) {
+ return keyPathComponent.replace(/~1/g, '.').replace(/~0/g, '~');
+ }
+ /**
+ * @param {PlainObject|GenericArray} obj
+ * @param {string} keyPath
+ * @returns {Any}
+ */
+
+
+ function getByKeyPath(obj, keyPath) {
+ if (keyPath === '') {
+ return obj;
+ }
+
+ var period = keyPath.indexOf('.');
+
+ if (period > -1) {
+ var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
+ return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.slice(period + 1));
+ }
+
+ return obj[unescapeKeyPathComponent(keyPath)];
+ }
+ /**
+ *
+ * @param {PlainObject} obj
+ * @param {string} keyPath
+ * @param {Any} value
+ * @returns {Any}
+ */
+
+
+ function setAtKeyPath(obj, keyPath, value) {
+ if (keyPath === '') {
+ return value;
+ }
+
+ var period = keyPath.indexOf('.');
+
+ if (period > -1) {
+ var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];
+ return setAtKeyPath(innerObj, keyPath.slice(period + 1), value);
+ }
+
+ obj[unescapeKeyPathComponent(keyPath)] = value;
+ return obj;
+ }
+ /**
+ *
+ * @param {external:JSON} value
+ * @returns {"null"|"array"|"undefined"|"boolean"|"number"|"string"|
+ * "object"|"symbol"}
+ */
+
+
+ function getJSONType(value) {
+ return value === null ? 'null' : Array.isArray(value) ? 'array' : _typeof(value);
+ }
+
+ var keys = Object.keys,
+ isArray = Array.isArray,
+ hasOwn$1 = {}.hasOwnProperty,
+ internalStateObjPropsToIgnore = ['type', 'replaced', 'iterateIn', 'iterateUnsetNumeric'];
+ /**
+ * Handle plain object revivers first so reference setting can use
+ * revived type (e.g., array instead of object); assumes revived
+ * has same structure or will otherwise break subsequent references.
+ * @param {PlainObjectType} a
+ * @param {PlainObjectType} b
+ * @returns {1|-1|boolean}
+ */
+
+ function nestedPathsFirst(a, b) {
+ if (a.keypath === '') {
+ return -1;
+ }
+
+ var as = a.keypath.match(/\./g) || 0;
+ var bs = b.keypath.match(/\./g) || 0;
+
+ if (as) {
+ as = as.length;
+ }
+
+ if (bs) {
+ bs = bs.length;
+ }
+
+ return as > bs ? -1 : as < bs ? 1 : a.keypath < b.keypath ? -1 : a.keypath > b.keypath;
+ }
+ /**
+ * An instance of this class can be used to call `stringify()` and `parse()`.
+ * Typeson resolves cyclic references by default. Can also be extended to
+ * support custom types using the register() method.
+ *
+ * @class
+ * @param {{cyclic: boolean}} [options] - if cyclic (default true),
+ * cyclic references will be handled gracefully.
+ */
+
+
+ var Typeson =
+ /*#__PURE__*/
+ function () {
+ function Typeson(options) {
+ _classCallCheck(this, Typeson);
+
+ this.options = options; // Replacers signature: replace (value). Returns falsy if not
+ // replacing. Otherwise ['Date', value.getTime()]
+
+ this.plainObjectReplacers = [];
+ this.nonplainObjectReplacers = []; // Revivers: [{type => reviver}, {plain: boolean}].
+ // Sample: [{'Date': value => new Date(value)}, {plain: false}]
+
+ this.revivers = {};
+ /** Types registered via `register()`. */
+
+ this.types = {};
+ }
+ /**
+ * @typedef {null|boolean|number|string|GenericArray|PlainObject} JSON
+ */
+
+ /**
+ * @callback JSONReplacer
+ * @param {""|string} key
+ * @param {JSON} value
+ * @returns {number|string|boolean|null|PlainObject|undefined}
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20replacer%20parameter
+ */
+
+ /**
+ * Serialize given object to Typeson.
+ * Initial arguments work identical to those of `JSON.stringify`.
+ * The `replacer` argument has nothing to do with our replacers.
+ * @param {Any} obj
+ * @param {JSONReplacer|string[]} replacer
+ * @param {number|string} space
+ * @param {object} opts
+ * @returns {string|Promise} Promise resolves to a string
+ */
+
+
+ _createClass(Typeson, [{
+ key: "stringify",
+ value: function stringify(obj, replacer, space, opts) {
+ opts = _objectSpread2({}, this.options, {}, opts, {
+ stringification: true
+ });
+ var encapsulated = this.encapsulate(obj, null, opts);
+
+ if (isArray(encapsulated)) {
+ return JSON.stringify(encapsulated[0], replacer, space);
+ }
+
+ return encapsulated.then(function (res) {
+ return JSON.stringify(res, replacer, space);
+ });
+ }
+ /**
+ * Also sync but throws on non-sync result.
+ * @param {Any} obj
+ * @param {JSONReplacer|string[]} replacer
+ * @param {number|string} space
+ * @param {object} opts
+ * @returns {string}
+ */
+
+ }, {
+ key: "stringifySync",
+ value: function stringifySync(obj, replacer, space, opts) {
+ return this.stringify(obj, replacer, space, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: true
+ }));
+ }
+ /**
+ *
+ * @param {Any} obj
+ * @param {JSONReplacer|string[]} replacer
+ * @param {number|string} space
+ * @param {object} opts
+ * @returns {Promise<string>}
+ */
+
+ }, {
+ key: "stringifyAsync",
+ value: function stringifyAsync(obj, replacer, space, opts) {
+ return this.stringify(obj, replacer, space, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: false
+ }));
+ }
+ /**
+ * Parse Typeson back into an obejct.
+ * Initial arguments works identical to those of `JSON.parse()`.
+ * @param {string} text
+ * @param {function} reviver This JSON reviver has nothing to do with
+ * our revivers.
+ * @param {object} opts
+ * @returns {external:JSON}
+ */
+
+ }, {
+ key: "parse",
+ value: function parse(text, reviver, opts) {
+ opts = _objectSpread2({}, this.options, {}, opts, {
+ parse: true
+ });
+ return this.revive(JSON.parse(text, reviver), opts);
+ }
+ /**
+ * Also sync but throws on non-sync result.
+ * @param {string} text
+ * @param {function} reviver This JSON reviver has nothing to do with
+ * our revivers.
+ * @param {object} opts
+ * @returns {external:JSON}
+ */
+
+ }, {
+ key: "parseSync",
+ value: function parseSync(text, reviver, opts) {
+ return this.parse(text, reviver, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: true
+ }));
+ }
+ /**
+ * @param {string} text
+ * @param {function} reviver This JSON reviver has nothing to do with
+ * our revivers.
+ * @param {object} opts
+ * @returns {Promise} Resolves to `external:JSON`
+ */
+
+ }, {
+ key: "parseAsync",
+ value: function parseAsync(text, reviver, opts) {
+ return this.parse(text, reviver, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: false
+ }));
+ }
+ /**
+ *
+ * @param {Any} obj
+ * @param {object} stateObj
+ * @param {object} [opts={}]
+ * @returns {string[]|false}
+ */
+
+ }, {
+ key: "specialTypeNames",
+ value: function specialTypeNames(obj, stateObj) {
+ var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+ opts.returnTypeNames = true;
+ return this.encapsulate(obj, stateObj, opts);
+ }
+ /**
+ *
+ * @param {Any} obj
+ * @param {PlainObject} stateObj
+ * @param {PlainObject} [opts={}]
+ * @returns {Promise|GenericArray|PlainObject|string|false}
+ */
+
+ }, {
+ key: "rootTypeName",
+ value: function rootTypeName(obj, stateObj) {
+ var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+ opts.iterateNone = true;
+ return this.encapsulate(obj, stateObj, opts);
+ }
+ /**
+ * Encapsulate a complex object into a plain Object by replacing
+ * registered types with plain objects representing the types data.
+ *
+ * This method is used internally by `Typeson.stringify()`.
+ * @param {Any} obj - Object to encapsulate.
+ * @param {PlainObject} stateObj
+ * @param {PlainObject} opts
+ * @returns {Promise|GenericArray|PlainObject|string|false}
+ */
+
+ }, {
+ key: "encapsulate",
+ value: function encapsulate(obj, stateObj, opts) {
+ opts = _objectSpread2({
+ sync: true
+ }, this.options, {}, opts);
+ var _opts = opts,
+ sync = _opts.sync;
+ var that = this,
+ types = {},
+ refObjs = [],
+ // For checking cyclic references
+ refKeys = [],
+ // For checking cyclic references
+ promisesDataRoot = []; // Clone the object deeply while at the same time replacing any
+ // special types or cyclic reference:
+
+ var cyclic = 'cyclic' in opts ? opts.cyclic : true;
+ var _opts2 = opts,
+ encapsulateObserver = _opts2.encapsulateObserver;
+
+ var ret = _encapsulate('', obj, cyclic, stateObj || {}, promisesDataRoot);
+ /**
+ *
+ * @param {Any} ret
+ * @returns {GenericArray|PlainObject|string|false}
+ */
+
+
+ function finish(ret) {
+ // Add `$types` to result only if we ever bumped into a
+ // special type (or special case where object has own `$types`)
+ var typeNames = Object.values(types);
+
+ if (opts.iterateNone) {
+ if (typeNames.length) {
+ return typeNames[0];
+ }
+
+ return Typeson.getJSONType(ret);
+ }
+
+ if (typeNames.length) {
+ if (opts.returnTypeNames) {
+ return _toConsumableArray(new Set(typeNames));
+ } // Special if array (or a primitive) was serialized
+ // because JSON would ignore custom `$types` prop on it
+
+
+ if (!ret || !isPlainObject(ret) || // Also need to handle if this is an object with its
+ // own `$types` property (to avoid ambiguity)
+ hasOwn$1.call(ret, '$types')) {
+ ret = {
+ $: ret,
+ $types: {
+ $: types
+ }
+ };
+ } else {
+ ret.$types = types;
+ } // No special types
+
+ } else if (isObject(ret) && hasOwn$1.call(ret, '$types')) {
+ ret = {
+ $: ret,
+ $types: true
+ };
+ }
+
+ if (opts.returnTypeNames) {
+ return false;
+ }
+
+ return ret;
+ }
+ /**
+ *
+ * @param {Any} ret
+ * @param {GenericArray} promisesData
+ * @returns {Promise<Any>}
+ */
+
+
+ function checkPromises(_x, _x2) {
+ return _checkPromises.apply(this, arguments);
+ }
+ /**
+ *
+ * @param {object} stateObj
+ * @param {object} ownKeysObj
+ * @param {function} cb
+ * @returns {undefined}
+ */
+
+
+ function _checkPromises() {
+ _checkPromises = _asyncToGenerator(
+ /*#__PURE__*/
+ regeneratorRuntime.mark(function _callee2(ret, promisesData) {
+ var promResults;
+ return regeneratorRuntime.wrap(function _callee2$(_context2) {
+ while (1) {
+ switch (_context2.prev = _context2.next) {
+ case 0:
+ _context2.next = 2;
+ return Promise.all(promisesData.map(function (pd) {
+ return pd[1].p;
+ }));
+
+ case 2:
+ promResults = _context2.sent;
+ _context2.next = 5;
+ return Promise.all(promResults.map(
+ /*#__PURE__*/
+ function () {
+ var _ref = _asyncToGenerator(
+ /*#__PURE__*/
+ regeneratorRuntime.mark(function _callee(promResult) {
+ var newPromisesData, _promisesData$splice, _promisesData$splice2, prData, _prData, keyPath, cyclic, stateObj, parentObj, key, detectedType, encaps, isTypesonPromise, encaps2;
+
+ return regeneratorRuntime.wrap(function _callee$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ newPromisesData = [];
+ _promisesData$splice = promisesData.splice(0, 1), _promisesData$splice2 = _slicedToArray(_promisesData$splice, 1), prData = _promisesData$splice2[0];
+ _prData = _slicedToArray(prData, 7), keyPath = _prData[0], cyclic = _prData[2], stateObj = _prData[3], parentObj = _prData[4], key = _prData[5], detectedType = _prData[6];
+ encaps = _encapsulate(keyPath, promResult, cyclic, stateObj, newPromisesData, true, detectedType);
+ isTypesonPromise = hasConstructorOf(encaps, TypesonPromise); // Handle case where an embedded custom type itself
+ // returns a `Typeson.Promise`
+
+ if (!(keyPath && isTypesonPromise)) {
+ _context.next = 11;
+ break;
+ }
+
+ _context.next = 8;
+ return encaps.p;
+
+ case 8:
+ encaps2 = _context.sent;
+ parentObj[key] = encaps2;
+ return _context.abrupt("return", checkPromises(ret, newPromisesData));
+
+ case 11:
+ if (keyPath) {
+ parentObj[key] = encaps;
+ } else if (isTypesonPromise) {
+ ret = encaps.p;
+ } else {
+ // If this is itself a `Typeson.Promise` (because the
+ // original value supplied was a `Promise` or
+ // because the supplied custom type value resolved
+ // to one), returning it below will be fine since
+ // a `Promise` is expected anyways given current
+ // config (and if not a `Promise`, it will be ready
+ // as the resolve value)
+ ret = encaps;
+ }
+
+ return _context.abrupt("return", checkPromises(ret, newPromisesData));
+
+ case 13:
+ case "end":
+ return _context.stop();
+ }
+ }
+ }, _callee);
+ }));
+
+ return function (_x3) {
+ return _ref.apply(this, arguments);
+ };
+ }()));
+
+ case 5:
+ return _context2.abrupt("return", ret);
+
+ case 6:
+ case "end":
+ return _context2.stop();
+ }
+ }
+ }, _callee2);
+ }));
+ return _checkPromises.apply(this, arguments);
+ }
+
+ function _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, cb) {
+ Object.assign(stateObj, ownKeysObj);
+ var vals = internalStateObjPropsToIgnore.map(function (prop) {
+ var tmp = stateObj[prop];
+ delete stateObj[prop];
+ return tmp;
+ }); // eslint-disable-next-line callback-return
+
+ cb();
+ internalStateObjPropsToIgnore.forEach(function (prop, i) {
+ stateObj[prop] = vals[i];
+ });
+ }
+ /**
+ *
+ * @param {string} keypath
+ * @param {Any} value
+ * @param {boolean} cyclic
+ * @param {PlainObject} stateObj
+ * @param {boolean} promisesData
+ * @param {boolean} resolvingTypesonPromise
+ * @param {string} detectedType
+ * @returns {Any}
+ */
+
+
+ function _encapsulate(keypath, value, cyclic, stateObj, promisesData, resolvingTypesonPromise, detectedType) {
+ var ret;
+ var observerData = {};
+
+ var $typeof = _typeof(value);
+
+ var runObserver = encapsulateObserver ? function (obj) {
+ var type = detectedType || stateObj.type || Typeson.getJSONType(value);
+ encapsulateObserver(Object.assign(obj || observerData, {
+ keypath: keypath,
+ value: value,
+ cyclic: cyclic,
+ stateObj: stateObj,
+ promisesData: promisesData,
+ resolvingTypesonPromise: resolvingTypesonPromise,
+ awaitingTypesonPromise: hasConstructorOf(value, TypesonPromise)
+ }, {
+ type: type
+ }));
+ } : null;
+
+ if (['string', 'boolean', 'number', 'undefined'].includes($typeof)) {
+ if (value === undefined || $typeof === 'number' && (isNaN(value) || value === -Infinity || value === Infinity)) {
+ if (stateObj.replaced) {
+ ret = value;
+ } else {
+ ret = replace(keypath, value, stateObj, promisesData, false, resolvingTypesonPromise, runObserver);
+ }
+
+ if (ret !== value) {
+ observerData = {
+ replaced: ret
+ };
+ }
+ } else {
+ ret = value;
+ }
+
+ if (runObserver) {
+ runObserver();
+ }
+
+ return ret;
+ }
+
+ if (value === null) {
+ if (runObserver) {
+ runObserver();
+ }
+
+ return value;
+ }
+
+ if (cyclic && !stateObj.iterateIn && !stateObj.iterateUnsetNumeric && value && _typeof(value) === 'object') {
+ // Options set to detect cyclic references and be able
+ // to rewrite them.
+ var refIndex = refObjs.indexOf(value);
+
+ if (refIndex < 0) {
+ if (cyclic === true) {
+ refObjs.push(value);
+ refKeys.push(keypath);
+ }
+ } else {
+ types[keypath] = '#';
+
+ if (runObserver) {
+ runObserver({
+ cyclicKeypath: refKeys[refIndex]
+ });
+ }
+
+ return '#' + refKeys[refIndex];
+ }
+ }
+
+ var isPlainObj = isPlainObject(value);
+ var isArr = isArray(value);
+ var replaced = // Running replace will cause infinite loop as will test
+ // positive again
+ (isPlainObj || isArr) && (!that.plainObjectReplacers.length || stateObj.replaced) || stateObj.iterateIn ? // Optimization: if plain object and no plain-object
+ // replacers, don't try finding a replacer
+ value : replace(keypath, value, stateObj, promisesData, isPlainObj || isArr, null, runObserver);
+ var clone;
+
+ if (replaced !== value) {
+ ret = replaced;
+ observerData = {
+ replaced: replaced
+ };
+ } else {
+ // eslint-disable-next-line no-lonely-if
+ if (keypath === '' && hasConstructorOf(value, TypesonPromise)) {
+ promisesData.push([keypath, value, cyclic, stateObj, undefined, undefined, stateObj.type]);
+ ret = value;
+ } else if (isArr && stateObj.iterateIn !== 'object' || stateObj.iterateIn === 'array') {
+ clone = new Array(value.length);
+ observerData = {
+ clone: clone
+ };
+ } else if (!['function', 'symbol'].includes(_typeof(value)) && !('toJSON' in value) && !hasConstructorOf(value, TypesonPromise) && !hasConstructorOf(value, Promise) && !hasConstructorOf(value, ArrayBuffer) || isPlainObj || stateObj.iterateIn === 'object') {
+ clone = {};
+
+ if (stateObj.addLength) {
+ clone.length = value.length;
+ }
+
+ observerData = {
+ clone: clone
+ };
+ } else {
+ ret = value; // Only clone vanilla objects and arrays
+ }
+ }
+
+ if (runObserver) {
+ runObserver();
+ }
+
+ if (opts.iterateNone) {
+ return clone || ret;
+ }
+
+ if (!clone) {
+ return ret;
+ } // Iterate object or array
+
+
+ if (stateObj.iterateIn) {
+ var _loop = function _loop(key) {
+ var ownKeysObj = {
+ ownKeys: hasOwn$1.call(value, key)
+ };
+
+ _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
+ var kp = keypath + (keypath ? '.' : '') + escapeKeyPathComponent(key);
+
+ var val = _encapsulate(kp, value[key], Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
+
+ if (hasConstructorOf(val, TypesonPromise)) {
+ promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, key, stateObj.type]);
+ } else if (val !== undefined) {
+ clone[key] = val;
+ }
+ });
+ };
+
+ // eslint-disable-next-line guard-for-in
+ for (var key in value) {
+ _loop(key);
+ }
+
+ if (runObserver) {
+ runObserver({
+ endIterateIn: true,
+ end: true
+ });
+ }
+ } else {
+ // Note: Non-indexes on arrays won't survive stringify so
+ // somewhat wasteful for arrays, but so too is iterating
+ // all numeric indexes on sparse arrays when not wanted
+ // or filtering own keys for positive integers
+ keys(value).forEach(function (key) {
+ var kp = keypath + (keypath ? '.' : '') + escapeKeyPathComponent(key);
+ var ownKeysObj = {
+ ownKeys: true
+ };
+
+ _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
+ var val = _encapsulate(kp, value[key], Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
+
+ if (hasConstructorOf(val, TypesonPromise)) {
+ promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, key, stateObj.type]);
+ } else if (val !== undefined) {
+ clone[key] = val;
+ }
+ });
+ });
+
+ if (runObserver) {
+ runObserver({
+ endIterateOwn: true,
+ end: true
+ });
+ }
+ } // Iterate array for non-own numeric properties (we can't
+ // replace the prior loop though as it iterates non-integer
+ // keys)
+
+
+ if (stateObj.iterateUnsetNumeric) {
+ var vl = value.length;
+
+ var _loop2 = function _loop2(i) {
+ if (!(i in value)) {
+ // No need to escape numeric
+ var kp = keypath + (keypath ? '.' : '') + i;
+ var ownKeysObj = {
+ ownKeys: false
+ };
+
+ _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, function () {
+ var val = _encapsulate(kp, undefined, Boolean(cyclic), stateObj, promisesData, resolvingTypesonPromise);
+
+ if (hasConstructorOf(val, TypesonPromise)) {
+ promisesData.push([kp, val, Boolean(cyclic), stateObj, clone, i, stateObj.type]);
+ } else if (val !== undefined) {
+ clone[i] = val;
+ }
+ });
+ }
+ };
+
+ for (var i = 0; i < vl; i++) {
+ _loop2(i);
+ }
+
+ if (runObserver) {
+ runObserver({
+ endIterateUnsetNumeric: true,
+ end: true
+ });
+ }
+ }
+
+ return clone;
+ }
+ /**
+ *
+ * @param {string} keypath
+ * @param {Any} value
+ * @param {PlainObject} stateObj
+ * @param {GenericArray} promisesData
+ * @param {boolean} plainObject
+ * @param {boolean} resolvingTypesonPromise
+ * @param {function} [runObserver]
+ * @returns {*}
+ */
+
+
+ function replace(keypath, value, stateObj, promisesData, plainObject, resolvingTypesonPromise, runObserver) {
+ // Encapsulate registered types
+ var replacers = plainObject ? that.plainObjectReplacers : that.nonplainObjectReplacers;
+ var i = replacers.length;
+
+ while (i--) {
+ var replacer = replacers[i];
+
+ if (replacer.test(value, stateObj)) {
+ var type = replacer.type;
+
+ if (that.revivers[type]) {
+ // Record the type only if a corresponding reviver
+ // exists. This is to support specs where only
+ // replacement is done.
+ // For example, ensuring deep cloning of the object,
+ // or replacing a type to its equivalent without
+ // the need to revive it.
+ var existing = types[keypath]; // type can comprise an array of types (see test
+ // "should support intermediate types")
+
+ types[keypath] = existing ? [type].concat(existing) : type;
+ }
+
+ Object.assign(stateObj, {
+ type: type,
+ replaced: true
+ });
+
+ if ((sync || !replacer.replaceAsync) && !replacer.replace) {
+ if (runObserver) {
+ runObserver({
+ typeDetected: true
+ });
+ }
+
+ return _encapsulate(keypath, value, cyclic && 'readonly', stateObj, promisesData, resolvingTypesonPromise, type);
+ }
+
+ if (runObserver) {
+ runObserver({
+ replacing: true
+ });
+ } // Now, also traverse the result in case it contains its
+ // own types to replace
+
+
+ var replaceMethod = sync || !replacer.replaceAsync ? 'replace' : 'replaceAsync';
+ return _encapsulate(keypath, replacer[replaceMethod](value, stateObj), cyclic && 'readonly', stateObj, promisesData, resolvingTypesonPromise, type);
+ }
+ }
+
+ return value;
+ }
+
+ return promisesDataRoot.length ? sync && opts.throwOnBadSyncType ? function () {
+ throw new TypeError('Sync method requested but async result obtained');
+ }() : Promise.resolve(checkPromises(ret, promisesDataRoot)).then(finish) : !sync && opts.throwOnBadSyncType ? function () {
+ throw new TypeError('Async method requested but sync result obtained');
+ }() // If this is a synchronous request for stringification, yet
+ // a promise is the result, we don't want to resolve leading
+ // to an async result, so we return an array to avoid
+ // ambiguity
+ : opts.stringification && sync ? [finish(ret)] : sync ? finish(ret) : Promise.resolve(finish(ret));
+ }
+ /**
+ * Also sync but throws on non-sync result.
+ * @param {*} obj
+ * @param {object} stateObj
+ * @param {object} opts
+ * @returns {*}
+ */
+
+ }, {
+ key: "encapsulateSync",
+ value: function encapsulateSync(obj, stateObj, opts) {
+ return this.encapsulate(obj, stateObj, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: true
+ }));
+ }
+ /**
+ * @param {*} obj
+ * @param {object} stateObj
+ * @param {object} opts
+ * @returns {*}
+ */
+
+ }, {
+ key: "encapsulateAsync",
+ value: function encapsulateAsync(obj, stateObj, opts) {
+ return this.encapsulate(obj, stateObj, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: false
+ }));
+ }
+ /**
+ * Revive an encapsulated object.
+ * This method is used internally by `Typeson.parse()`.
+ * @param {object} obj - Object to revive. If it has `$types` member, the
+ * properties that are listed there will be replaced with its true type
+ * instead of just plain objects.
+ * @param {object} opts
+ * @throws TypeError If mismatch between sync/async type and result
+ * @returns {Promise|*} If async, returns a Promise that resolves to `*`
+ */
+
+ }, {
+ key: "revive",
+ value: function revive(obj, opts) {
+ var types = obj && obj.$types; // No type info added. Revival not needed.
+
+ if (!types) {
+ return obj;
+ } // Object happened to have own `$types` property but with
+ // no actual types, so we unescape and return that object
+
+
+ if (types === true) {
+ return obj.$;
+ }
+
+ opts = _objectSpread2({
+ sync: true
+ }, this.options, {}, opts);
+ var _opts3 = opts,
+ sync = _opts3.sync;
+ var keyPathResolutions = [];
+ var stateObj = {};
+ var ignore$Types = true; // Special when root object is not a trivial Object, it will
+ // be encapsulated in `$`. It will also be encapsulated in
+ // `$` if it has its own `$` property to avoid ambiguity
+
+ if (types.$ && isPlainObject(types.$)) {
+ obj = obj.$;
+ types = types.$;
+ ignore$Types = false;
+ }
+
+ var that = this;
+ /**
+ * @callback RevivalReducer
+ * @param {Any} value
+ * @param {string} type
+ * @returns {Any}
+ */
+
+ /**
+ *
+ * @param {string} type
+ * @param {Any} val
+ * @returns {[type]} [description]
+ */
+
+ function executeReviver(type, val) {
+ var _ref2 = that.revivers[type] || [],
+ _ref3 = _slicedToArray(_ref2, 1),
+ reviver = _ref3[0];
+
+ if (!reviver) {
+ throw new Error('Unregistered type: ' + type);
+ } // Only `sync` expected here, as problematic async would
+ // be missing both `reviver` and `reviverAsync`, and
+ // encapsulation shouldn't have added types, so
+ // should have made an early exit
+
+
+ if (sync && !('revive' in reviver)) {
+ // Just return value as is
+ return val;
+ }
+
+ return reviver[sync && reviver.revive ? 'revive' : !sync && reviver.reviveAsync ? 'reviveAsync' : 'revive'](val, stateObj);
+ }
+ /**
+ *
+ * @returns {void|TypesonPromise<void>}
+ */
+
+
+ function revivePlainObjects() {
+ // const references = [];
+ // const reviveTypes = [];
+ var plainObjectTypes = [];
+ Object.entries(types).forEach(function (_ref4) {
+ var _ref5 = _slicedToArray(_ref4, 2),
+ keypath = _ref5[0],
+ type = _ref5[1];
+
+ if (type === '#') {
+ /*
+ references.push({
+ keypath,
+ reference: getByKeyPath(obj, keypath)
+ });
+ */
+ return;
+ }
+
+ [].concat(type).forEach(function (type) {
+ var _ref6 = that.revivers[type] || [null, {}],
+ _ref7 = _slicedToArray(_ref6, 2),
+ plain = _ref7[1].plain;
+
+ if (!plain) {
+ // reviveTypes.push({keypath, type});
+ return;
+ }
+
+ plainObjectTypes.push({
+ keypath: keypath,
+ type: type
+ });
+ delete types[keypath]; // Avoid repeating
+ });
+ });
+
+ if (!plainObjectTypes.length) {
+ return undefined;
+ } // console.log(plainObjectTypes.sort(nestedPathsFirst));
+
+ /**
+ * @typedef {PlainObject} PlainObjectType
+ * @property {string} keypath
+ * @property {string} type
+ */
+
+
+ return plainObjectTypes.sort(nestedPathsFirst).reduce(function reducer(possibleTypesonPromise, _ref8) {
+ var keypath = _ref8.keypath,
+ type = _ref8.type;
+
+ if (isThenable(possibleTypesonPromise)) {
+ return possibleTypesonPromise.then(function (val) {
+ return reducer(val, {
+ keypath: keypath,
+ type: type
+ });
+ });
+ } // console.log('obj', JSON.stringify(keypath), obj);
+
+
+ var val = getByKeyPath(obj, keypath);
+ val = executeReviver(type, val);
+
+ if (hasConstructorOf(val, TypesonPromise)) {
+ return val.then(function (v) {
+ var newVal = setAtKeyPath(obj, keypath, v);
+
+ if (newVal === v) {
+ obj = newVal;
+ }
+
+ return undefined;
+ });
+ }
+
+ var newVal = setAtKeyPath(obj, keypath, val);
+
+ if (newVal === val) {
+ obj = newVal;
+ }
+
+ return undefined;
+ }, undefined // This argument must be explicit
+ ); // references.forEach(({keypath, reference}) => {});
+ // reviveTypes.sort(nestedPathsFirst).forEach(() => {});
+ }
+
+ var revivalPromises = [];
+ /**
+ *
+ * @param {string} keypath
+ * @param {Any} value
+ * @param {?(Array|object)} target
+ * @param {Array|object} [clone]
+ * @param {string} [key]
+ * @returns {Any}
+ */
+
+ function _revive(keypath, value, target, clone, key) {
+ if (ignore$Types && keypath === '$types') {
+ return undefined;
+ }
+
+ var type = types[keypath];
+ var isArr = isArray(value);
+
+ if (isArr || isPlainObject(value)) {
+ var _clone = isArr ? new Array(value.length) : {}; // Iterate object or array
+
+
+ keys(value).forEach(function (k) {
+ var val = _revive(keypath + (keypath ? '.' : '') + escapeKeyPathComponent(k), value[k], target || _clone, _clone, k);
+
+ var set = function set(v) {
+ if (hasConstructorOf(v, Undefined)) {
+ _clone[k] = undefined;
+ } else if (v !== undefined) {
+ _clone[k] = v;
+ }
+
+ return v;
+ };
+
+ if (hasConstructorOf(val, TypesonPromise)) {
+ revivalPromises.push(val.then(function (ret) {
+ return set(ret);
+ }));
+ } else {
+ set(val);
+ }
+ });
+ value = _clone; // Try to resolve cyclic reference as soon as available
+
+ while (keyPathResolutions.length) {
+ var _keyPathResolutions$ = _slicedToArray(keyPathResolutions[0], 4),
+ _target = _keyPathResolutions$[0],
+ keyPath = _keyPathResolutions$[1],
+ _clone2 = _keyPathResolutions$[2],
+ k = _keyPathResolutions$[3];
+
+ var val = getByKeyPath(_target, keyPath); // Typeson.Undefined not expected here as not cyclic or
+ // `undefined`
+
+ if (val !== undefined) {
+ _clone2[k] = val;
+ } else {
+ break;
+ }
+
+ keyPathResolutions.splice(0, 1);
+ }
+ }
+
+ if (!type) {
+ return value;
+ }
+
+ if (type === '#') {
+ var _ret = getByKeyPath(target, value.slice(1));
+
+ if (_ret === undefined) {
+ // Cyclic reference not yet available
+ keyPathResolutions.push([target, value.slice(1), clone, key]);
+ }
+
+ return _ret;
+ } // `type` can be an array here
+
+
+ return [].concat(type).reduce(function reducer(val, typ) {
+ if (hasConstructorOf(val, TypesonPromise)) {
+ return val.then(function (v) {
+ // TypesonPromise here too
+ return reducer(v, typ);
+ });
+ }
+
+ return executeReviver(typ, val);
+ }, value);
+ }
+ /**
+ *
+ * @param {Any} retrn
+ * @returns {undefined|Any}
+ */
+
+
+ function checkUndefined(retrn) {
+ return hasConstructorOf(retrn, Undefined) ? undefined : retrn;
+ }
+
+ var possibleTypesonPromise = revivePlainObjects();
+ var ret;
+
+ if (hasConstructorOf(possibleTypesonPromise, TypesonPromise)) {
+ ret = possibleTypesonPromise.then(function () {
+ return obj;
+ });
+ } else {
+ ret = _revive('', obj, null);
+
+ if (revivalPromises.length) {
+ // Ensure children resolved
+ ret = TypesonPromise.resolve(ret).then(function (r) {
+ return TypesonPromise.all([// May be a TypesonPromise or not
+ r].concat(revivalPromises));
+ }).then(function (_ref9) {
+ var _ref10 = _slicedToArray(_ref9, 1),
+ r = _ref10[0];
+
+ return r;
+ });
+ }
+ }
+
+ return isThenable(ret) ? sync && opts.throwOnBadSyncType ? function () {
+ throw new TypeError('Sync method requested but async result obtained');
+ }() : hasConstructorOf(ret, TypesonPromise) ? ret.p.then(checkUndefined) : ret : !sync && opts.throwOnBadSyncType ? function () {
+ throw new TypeError('Async method requested but sync result obtained');
+ }() : sync ? checkUndefined(ret) : Promise.resolve(checkUndefined(ret));
+ }
+ /**
+ * Also sync but throws on non-sync result.
+ * @param {Any} obj
+ * @param {object} opts
+ * @returns {Any}
+ */
+
+ }, {
+ key: "reviveSync",
+ value: function reviveSync(obj, opts) {
+ return this.revive(obj, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: true
+ }));
+ }
+ /**
+ * @param {Any} obj
+ * @param {object} opts
+ * @returns {Promise} Resolves to `*`
+ */
+
+ }, {
+ key: "reviveAsync",
+ value: function reviveAsync(obj, opts) {
+ return this.revive(obj, _objectSpread2({
+ throwOnBadSyncType: true
+ }, opts, {
+ sync: false
+ }));
+ }
+ /**
+ * Register types.
+ * For examples on how to use this method, see
+ * {@link https://github.com/dfahlander/typeson-registry/tree/master/types}.
+ * @param {object.<string,Function[]>[]} typeSpecSets - Types and
+ * their functions [test, encapsulate, revive];
+ * @param {object} opts
+ * @returns {Typeson}
+ */
+
+ }, {
+ key: "register",
+ value: function register(typeSpecSets, opts) {
+ opts = opts || {};
+ [].concat(typeSpecSets).forEach(function R(typeSpec) {
+ var _this = this;
+
+ // Allow arrays of arrays of arrays...
+ if (isArray(typeSpec)) {
+ return typeSpec.map(function (typSpec) {
+ return R.call(_this, typSpec);
+ });
+ }
+
+ typeSpec && keys(typeSpec).forEach(function (typeId) {
+ if (typeId === '#') {
+ throw new TypeError('# cannot be used as a type name as it is reserved ' + 'for cyclic objects');
+ } else if (Typeson.JSON_TYPES.includes(typeId)) {
+ throw new TypeError('Plain JSON object types are reserved as type names');
+ }
+
+ var spec = typeSpec[typeId];
+ var replacers = spec && spec.testPlainObjects ? this.plainObjectReplacers : this.nonplainObjectReplacers;
+ var existingReplacer = replacers.filter(function (r) {
+ return r.type === typeId;
+ });
+
+ if (existingReplacer.length) {
+ // Remove existing spec and replace with this one.
+ replacers.splice(replacers.indexOf(existingReplacer[0]), 1);
+ delete this.revivers[typeId];
+ delete this.types[typeId];
+ }
+
+ if (typeof spec === 'function') {
+ // Support registering just a class without replacer/reviver
+ var Class = spec;
+ spec = {
+ test: function test(x) {
+ return x && x.constructor === Class;
+ },
+ replace: function replace(x) {
+ return _objectSpread2({}, x);
+ },
+ revive: function revive(x) {
+ return Object.assign(Object.create(Class.prototype), x);
+ }
+ };
+ } else if (isArray(spec)) {
+ var _spec = spec,
+ _spec2 = _slicedToArray(_spec, 3),
+ test = _spec2[0],
+ replace = _spec2[1],
+ revive = _spec2[2];
+
+ spec = {
+ test: test,
+ replace: replace,
+ revive: revive
+ };
+ }
+
+ if (!spec || !spec.test) {
+ return;
+ }
+
+ var replacerObj = {
+ type: typeId,
+ test: spec.test.bind(spec)
+ };
+
+ if (spec.replace) {
+ replacerObj.replace = spec.replace.bind(spec);
+ }
+
+ if (spec.replaceAsync) {
+ replacerObj.replaceAsync = spec.replaceAsync.bind(spec);
+ }
+
+ var start = typeof opts.fallback === 'number' ? opts.fallback : opts.fallback ? 0 : Infinity;
+
+ if (spec.testPlainObjects) {
+ this.plainObjectReplacers.splice(start, 0, replacerObj);
+ } else {
+ this.nonplainObjectReplacers.splice(start, 0, replacerObj);
+ } // Todo: We might consider a testAsync type
+
+
+ if (spec.revive || spec.reviveAsync) {
+ var reviverObj = {};
+
+ if (spec.revive) {
+ reviverObj.revive = spec.revive.bind(spec);
+ }
+
+ if (spec.reviveAsync) {
+ reviverObj.reviveAsync = spec.reviveAsync.bind(spec);
+ }
+
+ this.revivers[typeId] = [reviverObj, {
+ plain: spec.testPlainObjects
+ }];
+ } // Record to be retrieved via public types property.
+
+
+ this.types[typeId] = spec;
+ }, this);
+ }, this);
+ return this;
+ }
+ }]);
+
+ return Typeson;
+ }();
+ /**
+ * We keep this function minimized so if using two instances of this
+ * library, where one is minimized and one is not, it will still work
+ * with `hasConstructorOf`.
+ * @class
+ */
+
+
+ var Undefined = function Undefined() {
+ _classCallCheck(this, Undefined);
+ }; // eslint-disable-line space-before-blocks
+
+
+ Undefined.__typeson__type__ = 'TypesonUndefined'; // The following provide classes meant to avoid clashes with other values
+ // To insist `undefined` should be added
+
+ Typeson.Undefined = Undefined; // To support async encapsulation/stringification
+
+ Typeson.Promise = TypesonPromise; // Some fundamental type-checking utilities
+
+ Typeson.isThenable = isThenable;
+ Typeson.toStringTag = toStringTag;
+ Typeson.hasConstructorOf = hasConstructorOf;
+ Typeson.isObject = isObject;
+ Typeson.isPlainObject = isPlainObject;
+ Typeson.isUserObject = isUserObject;
+ Typeson.escapeKeyPathComponent = escapeKeyPathComponent;
+ Typeson.unescapeKeyPathComponent = unescapeKeyPathComponent;
+ Typeson.getByKeyPath = getByKeyPath;
+ Typeson.getJSONType = getJSONType;
+ Typeson.JSON_TYPES = ['null', 'boolean', 'number', 'string', 'array', 'object'];
+
+ return Typeson;
+
+ })));
+ });
+
+ var structuredCloning = createCommonjsModule(function (module, exports) {
+ !function(e,t){module.exports=t();}(commonjsGlobal,(function(){function _typeof$1(e){return (_typeof$1="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _classCallCheck$1(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties$1(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n);}}function _defineProperty$1(e,t,r){return t in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}function ownKeys$1(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),r.push.apply(r,n);}return r}function _toConsumableArray$1(e){return function _arrayWithoutHoles$1(e){if(Array.isArray(e))return _arrayLikeToArray$1(e)}(e)||function _iterableToArray$1(e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||function _unsupportedIterableToArray$1(e,t){if(!e)return;if("string"==typeof e)return _arrayLikeToArray$1(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);"Object"===r&&e.constructor&&(r=e.constructor.name);if("Map"===r||"Set"===r)return Array.from(e);if("Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r))return _arrayLikeToArray$1(e,t)}(e)||function _nonIterableSpread$1(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function _arrayLikeToArray$1(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r<t;r++)n[r]=e[r];return n}function _typeof(e){return (_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function _typeof(e){return typeof e}:function _typeof(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties(e,t){for(var r=0;r<t.length;r++){var n=t[r];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n);}}function _defineProperty(e,t,r){return t in e?Object.defineProperty(e,t,{value:r,enumerable:!0,configurable:!0,writable:!0}):e[t]=r,e}function ownKeys(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var n=Object.getOwnPropertySymbols(e);t&&(n=n.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),r.push.apply(r,n);}return r}function _objectSpread2(e){for(var t=1;t<arguments.length;t++){var r=null!=arguments[t]?arguments[t]:{};t%2?ownKeys(Object(r),!0).forEach((function(t){_defineProperty(e,t,r[t]);})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):ownKeys(Object(r)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(r,t));}));}return e}function _slicedToArray(e,t){return function _arrayWithHoles(e){if(Array.isArray(e))return e}(e)||function _iterableToArrayLimit(e,t){if("undefined"==typeof Symbol||!(Symbol.iterator in Object(e)))return;var r=[],n=!0,i=!1,o=void 0;try{for(var a,c=e[Symbol.iterator]();!(n=(a=c.next()).done)&&(r.push(a.value),!t||r.length!==t);n=!0);}catch(e){i=!0,o=e;}finally{try{n||null==c.return||c.return();}finally{if(i)throw o}}return r}(e,t)||_unsupportedIterableToArray(e,t)||function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function _toConsumableArray(e){return function _arrayWithoutHoles(e){if(Array.isArray(e))return _arrayLikeToArray(e)}(e)||function _iterableToArray(e){if("undefined"!=typeof Symbol&&Symbol.iterator in Object(e))return Array.from(e)}(e)||_unsupportedIterableToArray(e)||function _nonIterableSpread(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function _unsupportedIterableToArray(e,t){if(e){if("string"==typeof e)return _arrayLikeToArray(e,t);var r=Object.prototype.toString.call(e).slice(8,-1);return "Object"===r&&e.constructor&&(r=e.constructor.name),"Map"===r||"Set"===r?Array.from(e):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?_arrayLikeToArray(e,t):void 0}}function _arrayLikeToArray(e,t){(null==t||t>e.length)&&(t=e.length);for(var r=0,n=new Array(t);r<t;r++)n[r]=e[r];return n}var e=function TypesonPromise(e){_classCallCheck(this,TypesonPromise),this.p=new Promise(e);};e.__typeson__type__="TypesonPromise","undefined"!=typeof Symbol&&(e.prototype[Symbol.toStringTag]="TypesonPromise"),e.prototype.then=function(t,r){var n=this;return new e((function(e,i){n.p.then((function(r){e(t?t(r):r);})).catch((function(e){return r?r(e):Promise.reject(e)})).then(e,i);}))},e.prototype.catch=function(e){return this.then(null,e)},e.resolve=function(t){return new e((function(e){e(t);}))},e.reject=function(t){return new e((function(e,r){r(t);}))},["all","race"].forEach((function(t){e[t]=function(r){return new e((function(e,n){Promise[t](r.map((function(e){return e&&e.constructor&&"TypesonPromise"===e.constructor.__typeson__type__?e.p:e}))).then(e,n);}))};}));var t={}.toString,r={}.hasOwnProperty,n=Object.getPrototypeOf,i=r.toString;function isThenable(e,t){return isObject(e)&&"function"==typeof e.then&&(!t||"function"==typeof e.catch)}function toStringTag(e){return t.call(e).slice(8,-1)}function hasConstructorOf(e,t){if(!e||"object"!==_typeof(e))return !1;var o=n(e);if(!o)return null===t;var a=r.call(o,"constructor")&&o.constructor;return "function"!=typeof a?null===t:t===a||(null!==t&&i.call(a)===i.call(t)||"function"==typeof t&&"string"==typeof a.__typeson__type__&&a.__typeson__type__===t.__typeson__type__)}function isPlainObject(e){return !(!e||"Object"!==toStringTag(e))&&(!n(e)||hasConstructorOf(e,Object))}function isObject(e){return e&&"object"===_typeof(e)}function escapeKeyPathComponent(e){return e.replace(/~/g,"~0").replace(/\./g,"~1")}function unescapeKeyPathComponent(e){return e.replace(/~1/g,".").replace(/~0/g,"~")}function getByKeyPath(e,t){if(""===t)return e;var r=t.indexOf(".");if(r>-1){var n=e[unescapeKeyPathComponent(t.slice(0,r))];return void 0===n?void 0:getByKeyPath(n,t.slice(r+1))}return e[unescapeKeyPathComponent(t)]}function setAtKeyPath(e,t,r){if(""===t)return r;var n=t.indexOf(".");return n>-1?setAtKeyPath(e[unescapeKeyPathComponent(t.slice(0,n))],t.slice(n+1),r):(e[unescapeKeyPathComponent(t)]=r,e)}function _await(e,t,r){return r?t?t(e):e:(e&&e.then||(e=Promise.resolve(e)),t?e.then(t):e)}var o=Object.keys,a=Array.isArray,c={}.hasOwnProperty,u=["type","replaced","iterateIn","iterateUnsetNumeric"];function _async(e){return function(){for(var t=[],r=0;r<arguments.length;r++)t[r]=arguments[r];try{return Promise.resolve(e.apply(this,t))}catch(e){return Promise.reject(e)}}}function nestedPathsFirst(e,t){if(""===e.keypath)return -1;var r=e.keypath.match(/\./g)||0,n=t.keypath.match(/\./g)||0;return r&&(r=r.length),n&&(n=n.length),r>n?-1:r<n?1:e.keypath<t.keypath?-1:e.keypath>t.keypath}var s=function(){function Typeson(e){_classCallCheck(this,Typeson),this.options=e,this.plainObjectReplacers=[],this.nonplainObjectReplacers=[],this.revivers={},this.types={};}return function _createClass(e,t,r){return t&&_defineProperties(e.prototype,t),r&&_defineProperties(e,r),e}(Typeson,[{key:"stringify",value:function stringify(e,t,r,n){n=_objectSpread2(_objectSpread2(_objectSpread2({},this.options),n),{},{stringification:!0});var i=this.encapsulate(e,null,n);return a(i)?JSON.stringify(i[0],t,r):i.then((function(e){return JSON.stringify(e,t,r)}))}},{key:"stringifySync",value:function stringifySync(e,t,r,n){return this.stringify(e,t,r,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},n),{},{sync:!0}))}},{key:"stringifyAsync",value:function stringifyAsync(e,t,r,n){return this.stringify(e,t,r,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},n),{},{sync:!1}))}},{key:"parse",value:function parse(e,t,r){return r=_objectSpread2(_objectSpread2(_objectSpread2({},this.options),r),{},{parse:!0}),this.revive(JSON.parse(e,t),r)}},{key:"parseSync",value:function parseSync(e,t,r){return this.parse(e,t,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},r),{},{sync:!0}))}},{key:"parseAsync",value:function parseAsync(e,t,r){return this.parse(e,t,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},r),{},{sync:!1}))}},{key:"specialTypeNames",value:function specialTypeNames(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return r.returnTypeNames=!0,this.encapsulate(e,t,r)}},{key:"rootTypeName",value:function rootTypeName(e,t){var r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};return r.iterateNone=!0,this.encapsulate(e,t,r)}},{key:"encapsulate",value:function encapsulate(t,r,n){var i=_async((function(t,r){return _await(Promise.all(r.map((function(e){return e[1].p}))),(function(n){return _await(Promise.all(n.map(_async((function(n){var o=!1,a=[],c=_slicedToArray(r.splice(0,1),1),u=_slicedToArray(c[0],7),s=u[0],f=u[2],l=u[3],p=u[4],y=u[5],v=u[6],b=_encapsulate(s,n,f,l,a,!0,v),d=hasConstructorOf(b,e);return function _invoke(e,t){var r=e();return r&&r.then?r.then(t):t(r)}((function(){if(s&&d)return _await(b.p,(function(e){return p[y]=e,o=!0,i(t,a)}))}),(function(e){return o?e:(s?p[y]=b:t=d?b.p:b,i(t,a))}))})))),(function(){return t}))}))})),s=(n=_objectSpread2(_objectSpread2({sync:!0},this.options),n)).sync,f=this,l={},p=[],y=[],v=[],b=!("cyclic"in n)||n.cyclic,d=n.encapsulateObserver,h=_encapsulate("",t,b,r||{},v);function finish(e){var t=Object.values(l);if(n.iterateNone)return t.length?t[0]:Typeson.getJSONType(e);if(t.length){if(n.returnTypeNames)return _toConsumableArray(new Set(t));e&&isPlainObject(e)&&!c.call(e,"$types")?e.$types=l:e={$:e,$types:{$:l}};}else isObject(e)&&c.call(e,"$types")&&(e={$:e,$types:!0});return !n.returnTypeNames&&e}function _adaptBuiltinStateObjectProperties(e,t,r){Object.assign(e,t);var n=u.map((function(t){var r=e[t];return delete e[t],r}));r(),u.forEach((function(t,r){e[t]=n[r];}));}function _encapsulate(t,r,i,u,s,v,b){var h,g={},m=_typeof(r),O=d?function(n){var o=b||u.type||Typeson.getJSONType(r);d(Object.assign(n||g,{keypath:t,value:r,cyclic:i,stateObj:u,promisesData:s,resolvingTypesonPromise:v,awaitingTypesonPromise:hasConstructorOf(r,e)},{type:o}));}:null;if(["string","boolean","number","undefined"].includes(m))return void 0===r||Number.isNaN(r)||r===Number.NEGATIVE_INFINITY||r===Number.POSITIVE_INFINITY?(h=u.replaced?r:replace(t,r,u,s,!1,v,O))!==r&&(g={replaced:h}):h=r,O&&O(),h;if(null===r)return O&&O(),r;if(i&&!u.iterateIn&&!u.iterateUnsetNumeric&&r&&"object"===_typeof(r)){var _=p.indexOf(r);if(!(_<0))return l[t]="#",O&&O({cyclicKeypath:y[_]}),"#"+y[_];!0===i&&(p.push(r),y.push(t));}var j,S=isPlainObject(r),T=a(r),w=(S||T)&&(!f.plainObjectReplacers.length||u.replaced)||u.iterateIn?r:replace(t,r,u,s,S||T,null,O);if(w!==r?(h=w,g={replaced:w}):""===t&&hasConstructorOf(r,e)?(s.push([t,r,i,u,void 0,void 0,u.type]),h=r):T&&"object"!==u.iterateIn||"array"===u.iterateIn?(j=new Array(r.length),g={clone:j}):(["function","symbol"].includes(_typeof(r))||"toJSON"in r||hasConstructorOf(r,e)||hasConstructorOf(r,Promise)||hasConstructorOf(r,ArrayBuffer))&&!S&&"object"!==u.iterateIn?h=r:(j={},u.addLength&&(j.length=r.length),g={clone:j}),O&&O(),n.iterateNone)return j||h;if(!j)return h;if(u.iterateIn){var A=function _loop(n){var o={ownKeys:c.call(r,n)};_adaptBuiltinStateObjectProperties(u,o,(function(){var o=t+(t?".":"")+escapeKeyPathComponent(n),a=_encapsulate(o,r[n],Boolean(i),u,s,v);hasConstructorOf(a,e)?s.push([o,a,Boolean(i),u,j,n,u.type]):void 0!==a&&(j[n]=a);}));};for(var P in r)A(P);O&&O({endIterateIn:!0,end:!0});}else o(r).forEach((function(n){var o=t+(t?".":"")+escapeKeyPathComponent(n);_adaptBuiltinStateObjectProperties(u,{ownKeys:!0},(function(){var t=_encapsulate(o,r[n],Boolean(i),u,s,v);hasConstructorOf(t,e)?s.push([o,t,Boolean(i),u,j,n,u.type]):void 0!==t&&(j[n]=t);}));})),O&&O({endIterateOwn:!0,end:!0});if(u.iterateUnsetNumeric){for(var I=r.length,C=function _loop2(n){if(!(n in r)){var o=t+(t?".":"")+n;_adaptBuiltinStateObjectProperties(u,{ownKeys:!1},(function(){var t=_encapsulate(o,void 0,Boolean(i),u,s,v);hasConstructorOf(t,e)?s.push([o,t,Boolean(i),u,j,n,u.type]):void 0!==t&&(j[n]=t);}));}},N=0;N<I;N++)C(N);O&&O({endIterateUnsetNumeric:!0,end:!0});}return j}function replace(e,t,r,n,i,o,a){for(var c=i?f.plainObjectReplacers:f.nonplainObjectReplacers,u=c.length;u--;){var p=c[u];if(p.test(t,r)){var y=p.type;if(f.revivers[y]){var v=l[e];l[e]=v?[y].concat(v):y;}return Object.assign(r,{type:y,replaced:!0}),!s&&p.replaceAsync||p.replace?(a&&a({replacing:!0}),_encapsulate(e,p[s||!p.replaceAsync?"replace":"replaceAsync"](t,r),b&&"readonly",r,n,o,y)):(a&&a({typeDetected:!0}),_encapsulate(e,t,b&&"readonly",r,n,o,y))}}return t}return v.length?s&&n.throwOnBadSyncType?function(){throw new TypeError("Sync method requested but async result obtained")}():Promise.resolve(i(h,v)).then(finish):!s&&n.throwOnBadSyncType?function(){throw new TypeError("Async method requested but sync result obtained")}():n.stringification&&s?[finish(h)]:s?finish(h):Promise.resolve(finish(h))}},{key:"encapsulateSync",value:function encapsulateSync(e,t,r){return this.encapsulate(e,t,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},r),{},{sync:!0}))}},{key:"encapsulateAsync",value:function encapsulateAsync(e,t,r){return this.encapsulate(e,t,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},r),{},{sync:!1}))}},{key:"revive",value:function revive(t,r){var n=t&&t.$types;if(!n)return t;if(!0===n)return t.$;var i=(r=_objectSpread2(_objectSpread2({sync:!0},this.options),r)).sync,c=[],u={},s=!0;n.$&&isPlainObject(n.$)&&(t=t.$,n=n.$,s=!1);var l=this;function executeReviver(e,t){var r=_slicedToArray(l.revivers[e]||[],1)[0];if(!r)throw new Error("Unregistered type: "+e);return i&&!("revive"in r)?t:r[i&&r.revive?"revive":!i&&r.reviveAsync?"reviveAsync":"revive"](t,u)}var p=[];function checkUndefined(e){return hasConstructorOf(e,f)?void 0:e}var y,v=function revivePlainObjects(){var r=[];if(Object.entries(n).forEach((function(e){var t=_slicedToArray(e,2),i=t[0],o=t[1];"#"!==o&&[].concat(o).forEach((function(e){_slicedToArray(l.revivers[e]||[null,{}],2)[1].plain&&(r.push({keypath:i,type:e}),delete n[i]);}));})),r.length)return r.sort(nestedPathsFirst).reduce((function reducer(r,n){var i=n.keypath,o=n.type;if(isThenable(r))return r.then((function(e){return reducer(e,{keypath:i,type:o})}));var a=getByKeyPath(t,i);if(hasConstructorOf(a=executeReviver(o,a),e))return a.then((function(e){var r=setAtKeyPath(t,i,e);r===e&&(t=r);}));var c=setAtKeyPath(t,i,a);c===a&&(t=c);}),void 0)}();return hasConstructorOf(v,e)?y=v.then((function(){return t})):(y=function _revive(t,r,i,u,l){if(!s||"$types"!==t){var y=n[t],v=a(r);if(v||isPlainObject(r)){var b=v?new Array(r.length):{};for(o(r).forEach((function(n){var o=_revive(t+(t?".":"")+escapeKeyPathComponent(n),r[n],i||b,b,n),a=function set(e){return hasConstructorOf(e,f)?b[n]=void 0:void 0!==e&&(b[n]=e),e};hasConstructorOf(o,e)?p.push(o.then((function(e){return a(e)}))):a(o);})),r=b;c.length;){var d=_slicedToArray(c[0],4),h=d[0],g=d[1],m=d[2],O=d[3],_=getByKeyPath(h,g);if(void 0===_)break;m[O]=_,c.splice(0,1);}}if(!y)return r;if("#"===y){var j=getByKeyPath(i,r.slice(1));return void 0===j&&c.push([i,r.slice(1),u,l]),j}return [].concat(y).reduce((function reducer(t,r){return hasConstructorOf(t,e)?t.then((function(e){return reducer(e,r)})):executeReviver(r,t)}),r)}}("",t,null),p.length&&(y=e.resolve(y).then((function(t){return e.all([t].concat(p))})).then((function(e){return _slicedToArray(e,1)[0]})))),isThenable(y)?i&&r.throwOnBadSyncType?function(){throw new TypeError("Sync method requested but async result obtained")}():hasConstructorOf(y,e)?y.p.then(checkUndefined):y:!i&&r.throwOnBadSyncType?function(){throw new TypeError("Async method requested but sync result obtained")}():i?checkUndefined(y):Promise.resolve(checkUndefined(y))}},{key:"reviveSync",value:function reviveSync(e,t){return this.revive(e,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},t),{},{sync:!0}))}},{key:"reviveAsync",value:function reviveAsync(e,t){return this.revive(e,_objectSpread2(_objectSpread2({throwOnBadSyncType:!0},t),{},{sync:!1}))}},{key:"register",value:function register(e,t){return t=t||{},[].concat(e).forEach((function R(e){var r=this;if(a(e))return e.map((function(e){return R.call(r,e)}));e&&o(e).forEach((function(r){if("#"===r)throw new TypeError("# cannot be used as a type name as it is reserved for cyclic objects");if(Typeson.JSON_TYPES.includes(r))throw new TypeError("Plain JSON object types are reserved as type names");var n=e[r],i=n&&n.testPlainObjects?this.plainObjectReplacers:this.nonplainObjectReplacers,o=i.filter((function(e){return e.type===r}));if(o.length&&(i.splice(i.indexOf(o[0]),1),delete this.revivers[r],delete this.types[r]),"function"==typeof n){var c=n;n={test:function test(e){return e&&e.constructor===c},replace:function replace(e){return _objectSpread2({},e)},revive:function revive(e){return Object.assign(Object.create(c.prototype),e)}};}else if(a(n)){var u=_slicedToArray(n,3);n={test:u[0],replace:u[1],revive:u[2]};}if(n&&n.test){var s={type:r,test:n.test.bind(n)};n.replace&&(s.replace=n.replace.bind(n)),n.replaceAsync&&(s.replaceAsync=n.replaceAsync.bind(n));var f="number"==typeof t.fallback?t.fallback:t.fallback?0:Number.POSITIVE_INFINITY;if(n.testPlainObjects?this.plainObjectReplacers.splice(f,0,s):this.nonplainObjectReplacers.splice(f,0,s),n.revive||n.reviveAsync){var l={};n.revive&&(l.revive=n.revive.bind(n)),n.reviveAsync&&(l.reviveAsync=n.reviveAsync.bind(n)),this.revivers[r]=[l,{plain:n.testPlainObjects}];}this.types[r]=n;}}),this);}),this),this}}]),Typeson}(),f=function Undefined(){_classCallCheck(this,Undefined);};f.__typeson__type__="TypesonUndefined",s.Undefined=f,s.Promise=e,s.isThenable=isThenable,s.toStringTag=toStringTag,s.hasConstructorOf=hasConstructorOf,s.isObject=isObject,s.isPlainObject=isPlainObject,s.isUserObject=function isUserObject(e){if(!e||"Object"!==toStringTag(e))return !1;var t=n(e);return !t||(hasConstructorOf(e,Object)||isUserObject(t))},s.escapeKeyPathComponent=escapeKeyPathComponent,s.unescapeKeyPathComponent=unescapeKeyPathComponent,s.getByKeyPath=getByKeyPath,s.getJSONType=function getJSONType(e){return null===e?"null":Array.isArray(e)?"array":_typeof(e)},s.JSON_TYPES=["null","boolean","number","string","array","object"];for(var l={userObject:{test:function test(e,t){return s.isUserObject(e)},replace:function replace(e){return function _objectSpread2$1(e){for(var t=1;t<arguments.length;t++){var r=null!=arguments[t]?arguments[t]:{};t%2?ownKeys$1(Object(r),!0).forEach((function(t){_defineProperty$1(e,t,r[t]);})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):ownKeys$1(Object(r)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(r,t));}));}return e}({},e)},revive:function revive(e){return e}}},p=[{arrayNonindexKeys:{testPlainObjects:!0,test:function test(e,t){return !!Array.isArray(e)&&(Object.keys(e).some((function(e){return String(Number.parseInt(e))!==e}))&&(t.iterateIn="object",t.addLength=!0),!0)},replace:function replace(e,t){return t.iterateUnsetNumeric=!0,e},revive:function revive(e){if(Array.isArray(e))return e;var t=[];return Object.keys(e).forEach((function(r){var n=e[r];t[r]=n;})),t}}},{sparseUndefined:{test:function test(e,t){return void 0===e&&!1===t.ownKeys},replace:function replace(e){return 0},revive:function revive(e){}}}],y={undef:{test:function test(e,t){return void 0===e&&(t.ownKeys||!("ownKeys"in t))},replace:function replace(e){return 0},revive:function revive(e){return new s.Undefined}}},v={StringObject:{test:function test(e){return "String"===s.toStringTag(e)&&"object"===_typeof$1(e)},replace:function replace(e){return String(e)},revive:function revive(e){return new String(e)}},BooleanObject:{test:function test(e){return "Boolean"===s.toStringTag(e)&&"object"===_typeof$1(e)},replace:function replace(e){return Boolean(e)},revive:function revive(e){return new Boolean(e)}},NumberObject:{test:function test(e){return "Number"===s.toStringTag(e)&&"object"===_typeof$1(e)},replace:function replace(e){return Number(e)},revive:function revive(e){return new Number(e)}}},b=[{nan:{test:function test(e){return Number.isNaN(e)},replace:function replace(e){return "NaN"},revive:function revive(e){return Number.NaN}}},{infinity:{test:function test(e){return e===Number.POSITIVE_INFINITY},replace:function replace(e){return "Infinity"},revive:function revive(e){return Number.POSITIVE_INFINITY}}},{negativeInfinity:{test:function test(e){return e===Number.NEGATIVE_INFINITY},replace:function replace(e){return "-Infinity"},revive:function revive(e){return Number.NEGATIVE_INFINITY}}}],d={date:{test:function test(e){return "Date"===s.toStringTag(e)},replace:function replace(e){var t=e.getTime();return Number.isNaN(t)?"NaN":t},revive:function revive(e){return "NaN"===e?new Date(Number.NaN):new Date(e)}}},h={regexp:{test:function test(e){return "RegExp"===s.toStringTag(e)},replace:function replace(e){return {source:e.source,flags:(e.global?"g":"")+(e.ignoreCase?"i":"")+(e.multiline?"m":"")+(e.sticky?"y":"")+(e.unicode?"u":"")}},revive:function revive(e){var t=e.source,r=e.flags;return new RegExp(t,r)}}},g={map:{test:function test(e){return "Map"===s.toStringTag(e)},replace:function replace(e){return _toConsumableArray$1(e.entries())},revive:function revive(e){return new Map(e)}}},m={set:{test:function test(e){return "Set"===s.toStringTag(e)},replace:function replace(e){return _toConsumableArray$1(e.values())},revive:function revive(e){return new Set(e)}}},O="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",_=new Uint8Array(256),j=0;j<O.length;j++)_[O.charCodeAt(j)]=j;var S=function encode(e,t,r){null==r&&(r=e.byteLength);for(var n=new Uint8Array(e,t||0,r),i=n.length,o="",a=0;a<i;a+=3)o+=O[n[a]>>2],o+=O[(3&n[a])<<4|n[a+1]>>4],o+=O[(15&n[a+1])<<2|n[a+2]>>6],o+=O[63&n[a+2]];return i%3==2?o=o.slice(0,-1)+"=":i%3==1&&(o=o.slice(0,-2)+"=="),o},T=function decode(e){var t,r,n,i,o=e.length,a=.75*e.length,c=0;"="===e[e.length-1]&&(a--,"="===e[e.length-2]&&a--);for(var u=new ArrayBuffer(a),s=new Uint8Array(u),f=0;f<o;f+=4)t=_[e.charCodeAt(f)],r=_[e.charCodeAt(f+1)],n=_[e.charCodeAt(f+2)],i=_[e.charCodeAt(f+3)],s[c++]=t<<2|r>>4,s[c++]=(15&r)<<4|n>>2,s[c++]=(3&n)<<6|63&i;return u},w={arraybuffer:{test:function test(e){return "ArrayBuffer"===s.toStringTag(e)},replace:function replace(e,t){t.buffers||(t.buffers=[]);var r=t.buffers.indexOf(e);return r>-1?{index:r}:(t.buffers.push(e),S(e))},revive:function revive(e,t){if(t.buffers||(t.buffers=[]),"object"===_typeof$1(e))return t.buffers[e.index];var r=T(e);return t.buffers.push(r),r}}},A="undefined"==typeof self?commonjsGlobal:self,P={};["Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array"].forEach((function(e){var t=e,r=A[t];r&&(P[e.toLowerCase()]={test:function test(e){return s.toStringTag(e)===t},replace:function replace(e,t){var r=e.buffer,n=e.byteOffset,i=e.length;t.buffers||(t.buffers=[]);var o=t.buffers.indexOf(r);return o>-1?{index:o,byteOffset:n,length:i}:(t.buffers.push(r),{encoded:S(r),byteOffset:n,length:i})},revive:function revive(e,t){t.buffers||(t.buffers=[]);var n,i=e.byteOffset,o=e.length,a=e.encoded,c=e.index;return "index"in e?n=t.buffers[c]:(n=T(a),t.buffers.push(n)),new r(n,i,o)}});}));var I={dataview:{test:function test(e){return "DataView"===s.toStringTag(e)},replace:function replace(e,t){var r=e.buffer,n=e.byteOffset,i=e.byteLength;t.buffers||(t.buffers=[]);var o=t.buffers.indexOf(r);return o>-1?{index:o,byteOffset:n,byteLength:i}:(t.buffers.push(r),{encoded:S(r),byteOffset:n,byteLength:i})},revive:function revive(e,t){t.buffers||(t.buffers=[]);var r,n=e.byteOffset,i=e.byteLength,o=e.encoded,a=e.index;return "index"in e?r=t.buffers[a]:(r=T(o),t.buffers.push(r)),new DataView(r,n,i)}}},C={IntlCollator:{test:function test(e){return s.hasConstructorOf(e,Intl.Collator)},replace:function replace(e){return e.resolvedOptions()},revive:function revive(e){return new Intl.Collator(e.locale,e)}},IntlDateTimeFormat:{test:function test(e){return s.hasConstructorOf(e,Intl.DateTimeFormat)},replace:function replace(e){return e.resolvedOptions()},revive:function revive(e){return new Intl.DateTimeFormat(e.locale,e)}},IntlNumberFormat:{test:function test(e){return s.hasConstructorOf(e,Intl.NumberFormat)},replace:function replace(e){return e.resolvedOptions()},revive:function revive(e){return new Intl.NumberFormat(e.locale,e)}}};function string2arraybuffer(e){for(var t=new Uint8Array(e.length),r=0;r<e.length;r++)t[r]=e.charCodeAt(r);return t.buffer}var N={file:{test:function test(e){return "File"===s.toStringTag(e)},replace:function replace(e){var t=new XMLHttpRequest;if(t.overrideMimeType("text/plain; charset=x-user-defined"),t.open("GET",URL.createObjectURL(e),!1),t.send(),200!==t.status&&0!==t.status)throw new Error("Bad File access: "+t.status);return {type:e.type,stringContents:t.responseText,name:e.name,lastModified:e.lastModified}},revive:function revive(e){var t=e.name,r=e.type,n=e.stringContents,i=e.lastModified;return new File([string2arraybuffer(n)],t,{type:r,lastModified:i})},replaceAsync:function replaceAsync(e){return new s.Promise((function(t,r){var n=new FileReader;n.addEventListener("load",(function(){t({type:e.type,stringContents:n.result,name:e.name,lastModified:e.lastModified});})),n.addEventListener("error",(function(){r(n.error);})),n.readAsBinaryString(e);}))}}},k={bigint:{test:function test(e){return "bigint"==typeof e},replace:function replace(e){return String(e)},revive:function revive(e){return BigInt(e)}}},E={bigintObject:{test:function test(e){return "object"===_typeof$1(e)&&s.hasConstructorOf(e,BigInt)},replace:function replace(e){return String(e)},revive:function revive(e){return new Object(BigInt(e))}}},B={cryptokey:{test:function test(e){return "CryptoKey"===s.toStringTag(e)&&e.extractable},replaceAsync:function replaceAsync(e){return new s.Promise((function(t,r){crypto.subtle.exportKey("jwk",e).catch((function(e){r(e);})).then((function(r){t({jwk:r,algorithm:e.algorithm,usages:e.usages});}));}))},revive:function revive(e){var t=e.jwk,r=e.algorithm,n=e.usages;return crypto.subtle.importKey("jwk",t,r,!0,n)}}};return [l,y,p,v,b,d,h,{imagedata:{test:function test(e){return "ImageData"===s.toStringTag(e)},replace:function replace(e){return {array:_toConsumableArray$1(e.data),width:e.width,height:e.height}},revive:function revive(e){return new ImageData(new Uint8ClampedArray(e.array),e.width,e.height)}}},{imagebitmap:{test:function test(e){return "ImageBitmap"===s.toStringTag(e)||e&&e.dataset&&"ImageBitmap"===e.dataset.toStringTag},replace:function replace(e){var t=document.createElement("canvas");return t.getContext("2d").drawImage(e,0,0),t.toDataURL()},revive:function revive(e){var t=document.createElement("canvas"),r=t.getContext("2d"),n=document.createElement("img");return n.addEventListener("load",(function(){r.drawImage(n,0,0);})),n.src=e,t},reviveAsync:function reviveAsync(e){var t=document.createElement("canvas"),r=t.getContext("2d"),n=document.createElement("img");return n.addEventListener("load",(function(){r.drawImage(n,0,0);})),n.src=e,createImageBitmap(t)}}},N,{file:N.file,filelist:{test:function test(e){return "FileList"===s.toStringTag(e)},replace:function replace(e){for(var t=[],r=0;r<e.length;r++)t[r]=e.item(r);return t},revive:function revive(e){return new(function(){function FileList(){_classCallCheck$1(this,FileList),this._files=arguments[0],this.length=this._files.length;}return function _createClass$1(e,t,r){return t&&_defineProperties$1(e.prototype,t),r&&_defineProperties$1(e,r),e}(FileList,[{key:"item",value:function item(e){return this._files[e]}},{key:Symbol.toStringTag,get:function get(){return "FileList"}}]),FileList}())(e)}}},{blob:{test:function test(e){return "Blob"===s.toStringTag(e)},replace:function replace(e){var t=new XMLHttpRequest;if(t.overrideMimeType("text/plain; charset=x-user-defined"),t.open("GET",URL.createObjectURL(e),!1),t.send(),200!==t.status&&0!==t.status)throw new Error("Bad Blob access: "+t.status);return {type:e.type,stringContents:t.responseText}},revive:function revive(e){var t=e.type,r=e.stringContents;return new Blob([string2arraybuffer(r)],{type:t})},replaceAsync:function replaceAsync(e){return new s.Promise((function(t,r){var n=new FileReader;n.addEventListener("load",(function(){t({type:e.type,stringContents:n.result});})),n.addEventListener("error",(function(){r(n.error);})),n.readAsBinaryString(e);}))}}}].concat("function"==typeof Map?g:[],"function"==typeof Set?m:[],"function"==typeof ArrayBuffer?w:[],"function"==typeof Uint8Array?P:[],"function"==typeof DataView?I:[],"undefined"!=typeof Intl?C:[],"undefined"!=typeof crypto?B:[],"undefined"!=typeof BigInt?[k,E]:[])}));
+
+ });
+
+ /*
+ * base64-arraybuffer
+ * https://github.com/niklasvh/base64-arraybuffer
+ *
+ * Copyright (c) 2017 Brett Zamir, 2012 Niklas von Hertzen
+ * Licensed under the MIT license.
+ */
+ var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index.
+
+ var lookup = new Uint8Array(256);
+
+ for (var i = 0; i < chars.length; i++) {
+ lookup[chars.codePointAt(i)] = i;
+ }
+ /**
+ * @param {ArrayBuffer} arraybuffer
+ * @param {Integer} byteOffset
+ * @param {Integer} lngth
+ * @returns {string}
+ */
+
+
+ var encode = function encode(arraybuffer, byteOffset, lngth) {
+ if (lngth === null || lngth === undefined) {
+ lngth = arraybuffer.byteLength; // Needed for Safari
+ }
+
+ var bytes = new Uint8Array(arraybuffer, byteOffset || 0, // Default needed for Safari
+ lngth);
+ var len = bytes.length;
+ var base64 = '';
+
+ for (var _i = 0; _i < len; _i += 3) {
+ base64 += chars[bytes[_i] >> 2];
+ base64 += chars[(bytes[_i] & 3) << 4 | bytes[_i + 1] >> 4];
+ base64 += chars[(bytes[_i + 1] & 15) << 2 | bytes[_i + 2] >> 6];
+ base64 += chars[bytes[_i + 2] & 63];
+ }
+
+ if (len % 3 === 2) {
+ base64 = base64.slice(0, -1) + '=';
+ } else if (len % 3 === 1) {
+ base64 = base64.slice(0, -2) + '==';
+ }
+
+ return base64;
+ };
+ /**
+ * @param {string} base64
+ * @returns {ArrayBuffer}
+ */
+
+ var decode = function decode(base64) {
+ var len = base64.length;
+ var bufferLength = base64.length * 0.75;
+ var p = 0;
+ var encoded1, encoded2, encoded3, encoded4;
+
+ if (base64[base64.length - 1] === '=') {
+ bufferLength--;
+
+ if (base64[base64.length - 2] === '=') {
+ bufferLength--;
+ }
+ }
+
+ var arraybuffer = new ArrayBuffer(bufferLength),
+ bytes = new Uint8Array(arraybuffer);
+
+ for (var _i2 = 0; _i2 < len; _i2 += 4) {
+ encoded1 = lookup[base64.codePointAt(_i2)];
+ encoded2 = lookup[base64.codePointAt(_i2 + 1)];
+ encoded3 = lookup[base64.codePointAt(_i2 + 2)];
+ encoded4 = lookup[base64.codePointAt(_i2 + 3)];
+ bytes[p++] = encoded1 << 2 | encoded2 >> 4;
+ bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
+ bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
+ }
+
+ return arraybuffer;
+ };
+
+ /* eslint-env browser, node */
+ var _global = typeof self === 'undefined' ? global : self;
+ var exportObj = {};
+ [
+ 'Int8Array',
+ 'Uint8Array',
+ 'Uint8ClampedArray',
+ 'Int16Array',
+ 'Uint16Array',
+ 'Int32Array',
+ 'Uint32Array',
+ 'Float32Array',
+ 'Float64Array'
+ ].forEach(function (typeName) {
+ var arrType = typeName;
+ var TypedArray = _global[arrType];
+ if (TypedArray) {
+ exportObj[typeName.toLowerCase() + "2"] = {
+ test: function (x) { return typeson.toStringTag(x) === arrType; },
+ replace: function (_a) {
+ var buffer = _a.buffer, byteOffset = _a.byteOffset, length = _a.length;
+ return {
+ buffer: buffer,
+ byteOffset: byteOffset,
+ length: length
+ };
+ },
+ revive: function (b64Obj) {
+ var buffer = b64Obj.buffer, byteOffset = b64Obj.byteOffset, length = b64Obj.length;
+ return new TypedArray(buffer, byteOffset, length);
+ }
+ };
+ }
+ });
+
+ var arrayBuffer = {
+ arraybuffer: {
+ test: function (x) { return typeson.toStringTag(x) === 'ArrayBuffer'; },
+ replace: function (b) {
+ return encode(b, 0, b.byteLength);
+ },
+ revive: function (b64) {
+ var buffer = decode(b64);
+ return buffer;
+ }
+ }
+ };
+ // See also typed-arrays!
+
+ var TSON = new typeson().register(structuredCloning);
+ var readBlobsSynchronously = 'FileReaderSync' in self; // true in workers only.
+ var blobsToAwait = [];
+ var blobsToAwaitPos = 0;
+ // Need to patch encapsulateAsync as it does not work as of typeson 5.8.2
+ // Also, current version of typespn-registry-1.0.0-alpha.21 does not
+ // encapsulate/revive Blobs correctly (fails one of the unit tests in
+ // this library (test 'export-format'))
+ TSON.register([
+ arrayBuffer,
+ exportObj, {
+ blob2: {
+ test: function (x) { return typeson.toStringTag(x) === 'Blob'; },
+ replace: function (b) {
+ if (b.isClosed) { // On MDN, but not in https://w3c.github.io/FileAPI/#dfn-Blob
+ throw new Error('The Blob is closed');
+ }
+ if (readBlobsSynchronously) {
+ var data = readBlobSync(b, 'binary');
+ var base64 = encode(data, 0, data.byteLength);
+ return {
+ type: b.type,
+ data: base64
+ };
+ }
+ else {
+ blobsToAwait.push(b); // This will also make TSON.mustFinalize() return true.
+ var result = {
+ type: b.type,
+ data: { start: blobsToAwaitPos, end: blobsToAwaitPos + b.size }
+ };
+ blobsToAwaitPos += b.size;
+ return result;
+ }
+ },
+ finalize: function (b, ba) {
+ b.data = encode(ba, 0, ba.byteLength);
+ },
+ revive: function (_a) {
+ var type = _a.type, data = _a.data;
+ return new Blob([decode(data)], { type: type });
+ }
+ }
+ }
+ ]);
+ TSON.mustFinalize = function () { return blobsToAwait.length > 0; };
+ TSON.finalize = function (items) { return __awaiter(void 0, void 0, void 0, function () {
+ var allChunks, _i, items_1, item, types, arrayType, keyPath, typeName, typeSpec, b;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0: return [4 /*yield*/, readBlobAsync(new Blob(blobsToAwait), 'binary')];
+ case 1:
+ allChunks = _a.sent();
+ if (items) {
+ for (_i = 0, items_1 = items; _i < items_1.length; _i++) {
+ item = items_1[_i];
+ // Manually go through all "blob" types in the result
+ // and lookup the data slice they point at.
+ if (item.$types) {
+ types = item.$types;
+ arrayType = types.$;
+ if (arrayType)
+ types = types.$;
+ for (keyPath in types) {
+ typeName = types[keyPath];
+ typeSpec = TSON.types[typeName];
+ if (typeSpec && typeSpec.finalize) {
+ b = Dexie__default["default"].getByKeyPath(item, arrayType ? "$." + keyPath : keyPath);
+ typeSpec.finalize(b, allChunks.slice(b.start, b.end));
+ }
+ }
+ }
+ }
+ }
+ // Free up memory
+ blobsToAwait = [];
+ return [2 /*return*/];
+ }
+ });
+ }); };
+
+ var DEFAULT_ROWS_PER_CHUNK = 2000;
+ function exportDB(db, options) {
+ return __awaiter(this, void 0, void 0, function () {
+ function exportAll() {
+ return __awaiter(this, void 0, void 0, function () {
+ var tablesRowCounts, emptyExportJson, posEndDataArray, firstJsonSlice, filter, _loop_1, _i, tables_1, tableName;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0: return [4 /*yield*/, Promise.all(db.tables.map(function (table) { return table.count(); }))];
+ case 1:
+ tablesRowCounts = _a.sent();
+ tablesRowCounts.forEach(function (rowCount, i) { return tables[i].rowCount = rowCount; });
+ progress.totalRows = tablesRowCounts.reduce(function (p, c) { return p + c; });
+ emptyExportJson = JSON.stringify(emptyExport, undefined, prettyJson ? 2 : undefined);
+ posEndDataArray = emptyExportJson.lastIndexOf(']');
+ firstJsonSlice = emptyExportJson.substring(0, posEndDataArray);
+ slices.push(firstJsonSlice);
+ filter = options.filter;
+ _loop_1 = function (tableName) {
+ var table, primKey, inbound, LIMIT, emptyTableExport, emptyTableExportJson, posEndRowsArray, lastKey, lastNumRows, mayHaveMoreRows, _loop_2, state_1;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ table = db.table(tableName);
+ primKey = table.schema.primKey;
+ inbound = !!primKey.keyPath;
+ LIMIT = options.numRowsPerChunk || DEFAULT_ROWS_PER_CHUNK;
+ emptyTableExport = inbound ? {
+ tableName: table.name,
+ inbound: true,
+ rows: []
+ } : {
+ tableName: table.name,
+ inbound: false,
+ rows: []
+ };
+ emptyTableExportJson = JSON.stringify(emptyTableExport, undefined, prettyJson ? 2 : undefined);
+ if (prettyJson) {
+ // Increase indentation according to this:
+ // {
+ // ...
+ // data: [
+ // ...
+ // data: [
+ // 123456<---- here
+ // ]
+ // ]
+ // }
+ emptyTableExportJson = emptyTableExportJson.split('\n').join('\n ');
+ }
+ posEndRowsArray = emptyTableExportJson.lastIndexOf(']');
+ slices.push(emptyTableExportJson.substring(0, posEndRowsArray));
+ lastKey = null;
+ lastNumRows = 0;
+ mayHaveMoreRows = true;
+ _loop_2 = function () {
+ var chunkedCollection, values, filteredValues, tsonValues, json, keys, keyvals, tsonTuples, json;
+ return __generator(this, function (_c) {
+ switch (_c.label) {
+ case 0:
+ if (progressCallback) {
+ // Keep ongoing transaction private
+ Dexie__default["default"].ignoreTransaction(function () { return progressCallback(progress); });
+ }
+ chunkedCollection = lastKey == null ?
+ table.limit(LIMIT) :
+ table.where(':id').above(lastKey).limit(LIMIT);
+ return [4 /*yield*/, chunkedCollection.toArray()];
+ case 1:
+ values = _c.sent();
+ if (values.length === 0)
+ return [2 /*return*/, "break"];
+ if (lastKey != null && lastNumRows > 0) {
+ // Not initial chunk. Must add a comma:
+ slices.push(",");
+ if (prettyJson) {
+ slices.push("\n ");
+ }
+ }
+ mayHaveMoreRows = values.length === LIMIT;
+ if (!inbound) return [3 /*break*/, 4];
+ filteredValues = filter ?
+ values.filter(function (value) { return filter(tableName, value); }) :
+ values;
+ tsonValues = filteredValues.map(function (value) { return TSON.encapsulate(value); });
+ if (!TSON.mustFinalize()) return [3 /*break*/, 3];
+ return [4 /*yield*/, Dexie__default["default"].waitFor(TSON.finalize(tsonValues))];
+ case 2:
+ _c.sent();
+ _c.label = 3;
+ case 3:
+ json = JSON.stringify(tsonValues, undefined, prettyJson ? 2 : undefined);
+ if (prettyJson)
+ json = json.split('\n').join('\n ');
+ // By generating a blob here, we give web platform the opportunity to store the contents
+ // on disk and release RAM.
+ slices.push(new Blob([json.substring(1, json.length - 1)]));
+ lastNumRows = filteredValues.length;
+ lastKey = values.length > 0 ?
+ Dexie__default["default"].getByKeyPath(values[values.length - 1], primKey.keyPath) :
+ null;
+ return [3 /*break*/, 8];
+ case 4: return [4 /*yield*/, chunkedCollection.primaryKeys()];
+ case 5:
+ keys = _c.sent();
+ keyvals = keys.map(function (key, i) { return [key, values[i]]; });
+ if (filter)
+ keyvals = keyvals.filter(function (_a) {
+ var key = _a[0], value = _a[1];
+ return filter(tableName, value, key);
+ });
+ tsonTuples = keyvals.map(function (tuple) { return TSON.encapsulate(tuple); });
+ if (!TSON.mustFinalize()) return [3 /*break*/, 7];
+ return [4 /*yield*/, Dexie__default["default"].waitFor(TSON.finalize(tsonTuples))];
+ case 6:
+ _c.sent();
+ _c.label = 7;
+ case 7:
+ json = JSON.stringify(tsonTuples, undefined, prettyJson ? 2 : undefined);
+ if (prettyJson)
+ json = json.split('\n').join('\n ');
+ // By generating a blob here, we give web platform the opportunity to store the contents
+ // on disk and release RAM.
+ slices.push(new Blob([json.substring(1, json.length - 1)]));
+ lastNumRows = keyvals.length;
+ lastKey = keys.length > 0 ?
+ keys[keys.length - 1] :
+ null;
+ _c.label = 8;
+ case 8:
+ progress.completedRows += values.length;
+ return [2 /*return*/];
+ }
+ });
+ };
+ _b.label = 1;
+ case 1:
+ if (!mayHaveMoreRows) return [3 /*break*/, 3];
+ return [5 /*yield**/, _loop_2()];
+ case 2:
+ state_1 = _b.sent();
+ if (state_1 === "break")
+ return [3 /*break*/, 3];
+ return [3 /*break*/, 1];
+ case 3:
+ slices.push(emptyTableExportJson.substr(posEndRowsArray)); // "]}"
+ progress.completedTables += 1;
+ if (progress.completedTables < progress.totalTables) {
+ slices.push(",");
+ }
+ return [2 /*return*/];
+ }
+ });
+ };
+ _i = 0, tables_1 = tables;
+ _a.label = 2;
+ case 2:
+ if (!(_i < tables_1.length)) return [3 /*break*/, 5];
+ tableName = tables_1[_i].name;
+ return [5 /*yield**/, _loop_1(tableName)];
+ case 3:
+ _a.sent();
+ _a.label = 4;
+ case 4:
+ _i++;
+ return [3 /*break*/, 2];
+ case 5:
+ slices.push(emptyExportJson.substr(posEndDataArray));
+ progress.done = true;
+ if (progressCallback) {
+ // Keep ongoing transaction private
+ Dexie__default["default"].ignoreTransaction(function () { return progressCallback(progress); });
+ }
+ return [2 /*return*/];
+ }
+ });
+ });
+ }
+ var slices, tables, prettyJson, emptyExport, progressCallback, progress;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ options = options || {};
+ slices = [];
+ tables = db.tables.map(function (table) { return ({
+ name: table.name,
+ schema: getSchemaString(table),
+ rowCount: 0
+ }); });
+ prettyJson = options.prettyJson;
+ emptyExport = {
+ formatName: "dexie",
+ formatVersion: 1,
+ data: {
+ databaseName: db.name,
+ databaseVersion: db.verno,
+ tables: tables,
+ data: []
+ }
+ };
+ progressCallback = options.progressCallback;
+ progress = {
+ done: false,
+ completedRows: 0,
+ completedTables: 0,
+ totalRows: NaN,
+ totalTables: db.tables.length
+ };
+ _a.label = 1;
+ case 1:
+ _a.trys.push([1, , 6, 7]);
+ if (!options.noTransaction) return [3 /*break*/, 3];
+ return [4 /*yield*/, exportAll()];
+ case 2:
+ _a.sent();
+ return [3 /*break*/, 5];
+ case 3: return [4 /*yield*/, db.transaction('r', db.tables, exportAll)];
+ case 4:
+ _a.sent();
+ _a.label = 5;
+ case 5: return [3 /*break*/, 7];
+ case 6:
+ TSON.finalize(); // Free up mem if error has occurred
+ return [7 /*endfinally*/];
+ case 7: return [2 /*return*/, new Blob(slices, { type: "text/json" })];
+ }
+ });
+ });
+ }
+
+ var VERSION = 1;
+
+ var fakeStream = {Stream: function(){}};
+
+ var clarinet_1 = createCommonjsModule(function (module, exports) {
+ (function (clarinet) {
+
+ // non node-js needs to set clarinet debug on root
+ var env =(typeof process === 'object' && process.env)
+ ? process.env
+ : self;
+
+ clarinet.parser = function (opt) { return new CParser(opt);};
+ clarinet.CParser = CParser;
+ clarinet.CStream = CStream;
+ clarinet.createStream = createStream;
+ clarinet.MAX_BUFFER_LENGTH = 10 * 1024 * 1024;
+ clarinet.DEBUG = (env.CDEBUG==='debug');
+ clarinet.INFO = (env.CDEBUG==='debug' || env.CDEBUG==='info');
+ clarinet.EVENTS =
+ [ "value"
+ , "string"
+ , "key"
+ , "openobject"
+ , "closeobject"
+ , "openarray"
+ , "closearray"
+ , "error"
+ , "end"
+ , "ready"
+ ];
+
+ var buffers = {
+ textNode: undefined,
+ numberNode: ""
+ }
+ , streamWraps = clarinet.EVENTS.filter(function (ev) {
+ return ev !== "error" && ev !== "end";
+ })
+ , S = 0
+ , Stream
+ ;
+
+ clarinet.STATE =
+ { BEGIN : S++
+ , VALUE : S++ // general stuff
+ , OPEN_OBJECT : S++ // {
+ , CLOSE_OBJECT : S++ // }
+ , OPEN_ARRAY : S++ // [
+ , CLOSE_ARRAY : S++ // ]
+ , TEXT_ESCAPE : S++ // \ stuff
+ , STRING : S++ // ""
+ , BACKSLASH : S++
+ , END : S++ // No more stack
+ , OPEN_KEY : S++ // , "a"
+ , CLOSE_KEY : S++ // :
+ , TRUE : S++ // r
+ , TRUE2 : S++ // u
+ , TRUE3 : S++ // e
+ , FALSE : S++ // a
+ , FALSE2 : S++ // l
+ , FALSE3 : S++ // s
+ , FALSE4 : S++ // e
+ , NULL : S++ // u
+ , NULL2 : S++ // l
+ , NULL3 : S++ // l
+ , NUMBER_DECIMAL_POINT : S++ // .
+ , NUMBER_DIGIT : S++ // [0-9]
+ };
+
+ for (var s_ in clarinet.STATE) clarinet.STATE[clarinet.STATE[s_]] = s_;
+
+ // switcharoo
+ S = clarinet.STATE;
+
+ const Char = {
+ tab : 0x09, // \t
+ lineFeed : 0x0A, // \n
+ carriageReturn : 0x0D, // \r
+ space : 0x20, // " "
+
+ doubleQuote : 0x22, // "
+ plus : 0x2B, // +
+ comma : 0x2C, // ,
+ minus : 0x2D, // -
+ period : 0x2E, // .
+
+ _0 : 0x30, // 0
+ _9 : 0x39, // 9
+
+ colon : 0x3A, // :
+
+ E : 0x45, // E
+
+ openBracket : 0x5B, // [
+ backslash : 0x5C, // \
+ closeBracket : 0x5D, // ]
+
+ a : 0x61, // a
+ b : 0x62, // b
+ e : 0x65, // e
+ f : 0x66, // f
+ l : 0x6C, // l
+ n : 0x6E, // n
+ r : 0x72, // r
+ s : 0x73, // s
+ t : 0x74, // t
+ u : 0x75, // u
+
+ openBrace : 0x7B, // {
+ closeBrace : 0x7D, // }
+ };
+
+ if (!Object.create) {
+ Object.create = function (o) {
+ function f () { this["__proto__"] = o; }
+ f.prototype = o;
+ return new f;
+ };
+ }
+
+ if (!Object.getPrototypeOf) {
+ Object.getPrototypeOf = function (o) {
+ return o["__proto__"];
+ };
+ }
+
+ if (!Object.keys) {
+ Object.keys = function (o) {
+ var a = [];
+ for (var i in o) if (o.hasOwnProperty(i)) a.push(i);
+ return a;
+ };
+ }
+
+ function checkBufferLength (parser) {
+ var maxAllowed = Math.max(clarinet.MAX_BUFFER_LENGTH, 10)
+ , maxActual = 0
+ ;
+ for (var buffer in buffers) {
+ var len = parser[buffer] === undefined ? 0 : parser[buffer].length;
+ if (len > maxAllowed) {
+ switch (buffer) {
+ case "text":
+ closeText(parser);
+ break;
+
+ default:
+ error(parser, "Max buffer length exceeded: "+ buffer);
+ }
+ }
+ maxActual = Math.max(maxActual, len);
+ }
+ parser.bufferCheckPosition = (clarinet.MAX_BUFFER_LENGTH - maxActual)
+ + parser.position;
+ }
+
+ function clearBuffers (parser) {
+ for (var buffer in buffers) {
+ parser[buffer] = buffers[buffer];
+ }
+ }
+
+ var stringTokenPattern = /[\\"\n]/g;
+
+ function CParser (opt) {
+ if (!(this instanceof CParser)) return new CParser (opt);
+
+ var parser = this;
+ clearBuffers(parser);
+ parser.bufferCheckPosition = clarinet.MAX_BUFFER_LENGTH;
+ parser.q = parser.c = parser.p = "";
+ parser.opt = opt || {};
+ parser.closed = parser.closedRoot = parser.sawRoot = false;
+ parser.tag = parser.error = null;
+ parser.state = S.BEGIN;
+ parser.stack = new Array();
+ // mostly just for error reporting
+ parser.position = parser.column = 0;
+ parser.line = 1;
+ parser.slashed = false;
+ parser.unicodeI = 0;
+ parser.unicodeS = null;
+ parser.depth = 0;
+ emit(parser, "onready");
+ }
+
+ CParser.prototype =
+ { end : function () { end(this); }
+ , write : write
+ , resume : function () { this.error = null; return this; }
+ , close : function () { return this.write(null); }
+ };
+
+ try { Stream = fakeStream.Stream; }
+ catch (ex) { Stream = function () {}; }
+
+ function createStream (opt) { return new CStream(opt); }
+
+ function CStream (opt) {
+ if (!(this instanceof CStream)) return new CStream(opt);
+
+ this._parser = new CParser(opt);
+ this.writable = true;
+ this.readable = true;
+
+ //var Buffer = this.Buffer || function Buffer () {}; // if we don't have Buffers, fake it so we can do `var instanceof Buffer` and not throw an error
+ this.bytes_remaining = 0; // number of bytes remaining in multi byte utf8 char to read after split boundary
+ this.bytes_in_sequence = 0; // bytes in multi byte utf8 char to read
+ this.temp_buffs = { "2": new Buffer(2), "3": new Buffer(3), "4": new Buffer(4) }; // for rebuilding chars split before boundary is reached
+ this.string = '';
+
+ var me = this;
+ Stream.apply(me);
+
+ this._parser.onend = function () { me.emit("end"); };
+ this._parser.onerror = function (er) {
+ me.emit("error", er);
+ me._parser.error = null;
+ };
+
+ streamWraps.forEach(function (ev) {
+ Object.defineProperty(me, "on" + ev,
+ { get : function () { return me._parser["on" + ev]; }
+ , set : function (h) {
+ if (!h) {
+ me.removeAllListeners(ev);
+ me._parser["on"+ev] = h;
+ return h;
+ }
+ me.on(ev, h);
+ }
+ , enumerable : true
+ , configurable : false
+ });
+ });
+ }
+
+ CStream.prototype = Object.create(Stream.prototype,
+ { constructor: { value: CStream } });
+
+ CStream.prototype.write = function (data) {
+ data = new Buffer(data);
+ for (var i = 0; i < data.length; i++) {
+ var n = data[i];
+
+ // check for carry over of a multi byte char split between data chunks
+ // & fill temp buffer it with start of this data chunk up to the boundary limit set in the last iteration
+ if (this.bytes_remaining > 0) {
+ for (var j = 0; j < this.bytes_remaining; j++) {
+ this.temp_buffs[this.bytes_in_sequence][this.bytes_in_sequence - this.bytes_remaining + j] = data[j];
+ }
+ this.string = this.temp_buffs[this.bytes_in_sequence].toString();
+ this.bytes_in_sequence = this.bytes_remaining = 0;
+
+ // move iterator forward by number of byte read during sequencing
+ i = i + j - 1;
+
+ // pass data to parser and move forward to parse rest of data
+ this._parser.write(this.string);
+ this.emit("data", this.string);
+ continue;
+ }
+
+ // if no remainder bytes carried over, parse multi byte (>=128) chars one at a time
+ if (this.bytes_remaining === 0 && n >= 128) {
+ if ((n >= 194) && (n <= 223)) this.bytes_in_sequence = 2;
+ if ((n >= 224) && (n <= 239)) this.bytes_in_sequence = 3;
+ if ((n >= 240) && (n <= 244)) this.bytes_in_sequence = 4;
+ if ((this.bytes_in_sequence + i) > data.length) { // if bytes needed to complete char fall outside data length, we have a boundary split
+
+ for (var k = 0; k <= (data.length - 1 - i); k++) {
+ this.temp_buffs[this.bytes_in_sequence][k] = data[i + k]; // fill temp data of correct size with bytes available in this chunk
+ }
+ this.bytes_remaining = (i + this.bytes_in_sequence) - data.length;
+
+ // immediately return as we need another chunk to sequence the character
+ return true;
+ } else {
+ this.string = data.slice(i, (i + this.bytes_in_sequence)).toString();
+ i = i + this.bytes_in_sequence - 1;
+
+ this._parser.write(this.string);
+ this.emit("data", this.string);
+ continue;
+ }
+ }
+
+ // is there a range of characters that are immediately parsable?
+ for (var p = i; p < data.length; p++) {
+ if (data[p] >= 128) break;
+ }
+ this.string = data.slice(i, p).toString();
+ this._parser.write(this.string);
+ this.emit("data", this.string);
+ i = p - 1;
+
+ // handle any remaining characters using multibyte logic
+ continue;
+ }
+ };
+
+ CStream.prototype.end = function (chunk) {
+ if (chunk && chunk.length) this._parser.write(chunk.toString());
+ this._parser.end();
+ return true;
+ };
+
+ CStream.prototype.on = function (ev, handler) {
+ var me = this;
+ if (!me._parser["on"+ev] && streamWraps.indexOf(ev) !== -1) {
+ me._parser["on"+ev] = function () {
+ var args = arguments.length === 1 ? [arguments[0]]
+ : Array.apply(null, arguments);
+ args.splice(0, 0, ev);
+ me.emit.apply(me, args);
+ };
+ }
+ return Stream.prototype.on.call(me, ev, handler);
+ };
+
+ CStream.prototype.destroy = function () {
+ clearBuffers(this._parser);
+ this.emit("close");
+ };
+
+ function emit(parser, event, data) {
+ if(clarinet.INFO) console.log('-- emit', event, data);
+ if (parser[event]) parser[event](data);
+ }
+
+ function emitNode(parser, event, data) {
+ closeValue(parser);
+ emit(parser, event, data);
+ }
+
+ function closeValue(parser, event) {
+ parser.textNode = textopts(parser.opt, parser.textNode);
+ if (parser.textNode !== undefined) {
+ emit(parser, (event ? event : "onvalue"), parser.textNode);
+ }
+ parser.textNode = undefined;
+ }
+
+ function closeNumber(parser) {
+ if (parser.numberNode)
+ emit(parser, "onvalue", parseFloat(parser.numberNode));
+ parser.numberNode = "";
+ }
+
+ function textopts (opt, text) {
+ if (text === undefined) {
+ return text;
+ }
+ if (opt.trim) text = text.trim();
+ if (opt.normalize) text = text.replace(/\s+/g, " ");
+ return text;
+ }
+
+ function error (parser, er) {
+ closeValue(parser);
+ er += "\nLine: "+parser.line+
+ "\nColumn: "+parser.column+
+ "\nChar: "+parser.c;
+ er = new Error(er);
+ parser.error = er;
+ emit(parser, "onerror", er);
+ return parser;
+ }
+
+ function end(parser) {
+ if (parser.state !== S.VALUE || parser.depth !== 0)
+ error(parser, "Unexpected end");
+
+ closeValue(parser);
+ parser.c = "";
+ parser.closed = true;
+ emit(parser, "onend");
+ CParser.call(parser, parser.opt);
+ return parser;
+ }
+
+ function isWhitespace(c) {
+ return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
+ }
+
+ function write (chunk) {
+ var parser = this;
+ if (this.error) throw this.error;
+ if (parser.closed) return error(parser,
+ "Cannot write after close. Assign an onready handler.");
+ if (chunk === null) return end(parser);
+ var i = 0, c = chunk.charCodeAt(0), p = parser.p;
+ if (clarinet.DEBUG) console.log('write -> [' + chunk + ']');
+ while (c) {
+ p = c;
+ parser.c = c = chunk.charCodeAt(i++);
+ // if chunk doesnt have next, like streaming char by char
+ // this way we need to check if previous is really previous
+ // if not we need to reset to what the parser says is the previous
+ // from buffer
+ if(p !== c ) parser.p = p;
+ else p = parser.p;
+
+ if(!c) break;
+
+ if (clarinet.DEBUG) console.log(i,c,clarinet.STATE[parser.state]);
+ parser.position ++;
+ if (c === Char.lineFeed) {
+ parser.line ++;
+ parser.column = 0;
+ } else parser.column ++;
+ switch (parser.state) {
+
+ case S.BEGIN:
+ if (c === Char.openBrace) parser.state = S.OPEN_OBJECT;
+ else if (c === Char.openBracket) parser.state = S.OPEN_ARRAY;
+ else if (!isWhitespace(c))
+ error(parser, "Non-whitespace before {[.");
+ continue;
+
+ case S.OPEN_KEY:
+ case S.OPEN_OBJECT:
+ if (isWhitespace(c)) continue;
+ if(parser.state === S.OPEN_KEY) parser.stack.push(S.CLOSE_KEY);
+ else {
+ if(c === Char.closeBrace) {
+ emit(parser, 'onopenobject');
+ this.depth++;
+ emit(parser, 'oncloseobject');
+ this.depth--;
+ parser.state = parser.stack.pop() || S.VALUE;
+ continue;
+ } else parser.stack.push(S.CLOSE_OBJECT);
+ }
+ if(c === Char.doubleQuote) parser.state = S.STRING;
+ else error(parser, "Malformed object key should start with \"");
+ continue;
+
+ case S.CLOSE_KEY:
+ case S.CLOSE_OBJECT:
+ if (isWhitespace(c)) continue;
+ (parser.state === S.CLOSE_KEY) ? 'key' : 'object';
+ if(c === Char.colon) {
+ if(parser.state === S.CLOSE_OBJECT) {
+ parser.stack.push(S.CLOSE_OBJECT);
+ closeValue(parser, 'onopenobject');
+ this.depth++;
+ } else closeValue(parser, 'onkey');
+ parser.state = S.VALUE;
+ } else if (c === Char.closeBrace) {
+ emitNode(parser, 'oncloseobject');
+ this.depth--;
+ parser.state = parser.stack.pop() || S.VALUE;
+ } else if(c === Char.comma) {
+ if(parser.state === S.CLOSE_OBJECT)
+ parser.stack.push(S.CLOSE_OBJECT);
+ closeValue(parser);
+ parser.state = S.OPEN_KEY;
+ } else error(parser, 'Bad object');
+ continue;
+
+ case S.OPEN_ARRAY: // after an array there always a value
+ case S.VALUE:
+ if (isWhitespace(c)) continue;
+ if(parser.state===S.OPEN_ARRAY) {
+ emit(parser, 'onopenarray');
+ this.depth++;
+ parser.state = S.VALUE;
+ if(c === Char.closeBracket) {
+ emit(parser, 'onclosearray');
+ this.depth--;
+ parser.state = parser.stack.pop() || S.VALUE;
+ continue;
+ } else {
+ parser.stack.push(S.CLOSE_ARRAY);
+ }
+ }
+ if(c === Char.doubleQuote) parser.state = S.STRING;
+ else if(c === Char.openBrace) parser.state = S.OPEN_OBJECT;
+ else if(c === Char.openBracket) parser.state = S.OPEN_ARRAY;
+ else if(c === Char.t) parser.state = S.TRUE;
+ else if(c === Char.f) parser.state = S.FALSE;
+ else if(c === Char.n) parser.state = S.NULL;
+ else if(c === Char.minus) { // keep and continue
+ parser.numberNode += "-";
+ } else if(Char._0 <= c && c <= Char._9) {
+ parser.numberNode += String.fromCharCode(c);
+ parser.state = S.NUMBER_DIGIT;
+ } else error(parser, "Bad value");
+ continue;
+
+ case S.CLOSE_ARRAY:
+ if(c === Char.comma) {
+ parser.stack.push(S.CLOSE_ARRAY);
+ closeValue(parser, 'onvalue');
+ parser.state = S.VALUE;
+ } else if (c === Char.closeBracket) {
+ emitNode(parser, 'onclosearray');
+ this.depth--;
+ parser.state = parser.stack.pop() || S.VALUE;
+ } else if (isWhitespace(c))
+ continue;
+ else error(parser, 'Bad array');
+ continue;
+
+ case S.STRING:
+ if (parser.textNode === undefined) {
+ parser.textNode = "";
+ }
+
+ // thanks thejh, this is an about 50% performance improvement.
+ var starti = i-1
+ , slashed = parser.slashed
+ , unicodeI = parser.unicodeI
+ ;
+ STRING_BIGLOOP: while (true) {
+ if (clarinet.DEBUG)
+ console.log(i,c,clarinet.STATE[parser.state]
+ ,slashed);
+ // zero means "no unicode active". 1-4 mean "parse some more". end after 4.
+ while (unicodeI > 0) {
+ parser.unicodeS += String.fromCharCode(c);
+ c = chunk.charCodeAt(i++);
+ parser.position++;
+ if (unicodeI === 4) {
+ // TODO this might be slow? well, probably not used too often anyway
+ parser.textNode += String.fromCharCode(parseInt(parser.unicodeS, 16));
+ unicodeI = 0;
+ starti = i-1;
+ } else {
+ unicodeI++;
+ }
+ // we can just break here: no stuff we skipped that still has to be sliced out or so
+ if (!c) break STRING_BIGLOOP;
+ }
+ if (c === Char.doubleQuote && !slashed) {
+ parser.state = parser.stack.pop() || S.VALUE;
+ parser.textNode += chunk.substring(starti, i-1);
+ parser.position += i - 1 - starti;
+ break;
+ }
+ if (c === Char.backslash && !slashed) {
+ slashed = true;
+ parser.textNode += chunk.substring(starti, i-1);
+ parser.position += i - 1 - starti;
+ c = chunk.charCodeAt(i++);
+ parser.position++;
+ if (!c) break;
+ }
+ if (slashed) {
+ slashed = false;
+ if (c === Char.n) { parser.textNode += '\n'; }
+ else if (c === Char.r) { parser.textNode += '\r'; }
+ else if (c === Char.t) { parser.textNode += '\t'; }
+ else if (c === Char.f) { parser.textNode += '\f'; }
+ else if (c === Char.b) { parser.textNode += '\b'; }
+ else if (c === Char.u) {
+ // \uxxxx. meh!
+ unicodeI = 1;
+ parser.unicodeS = '';
+ } else {
+ parser.textNode += String.fromCharCode(c);
+ }
+ c = chunk.charCodeAt(i++);
+ parser.position++;
+ starti = i-1;
+ if (!c) break;
+ else continue;
+ }
+
+ stringTokenPattern.lastIndex = i;
+ var reResult = stringTokenPattern.exec(chunk);
+ if (reResult === null) {
+ i = chunk.length+1;
+ parser.textNode += chunk.substring(starti, i-1);
+ parser.position += i - 1 - starti;
+ break;
+ }
+ i = reResult.index+1;
+ c = chunk.charCodeAt(reResult.index);
+ if (!c) {
+ parser.textNode += chunk.substring(starti, i-1);
+ parser.position += i - 1 - starti;
+ break;
+ }
+ }
+ parser.slashed = slashed;
+ parser.unicodeI = unicodeI;
+ continue;
+
+ case S.TRUE:
+ if (c === Char.r) parser.state = S.TRUE2;
+ else error(parser, 'Invalid true started with t'+ c);
+ continue;
+
+ case S.TRUE2:
+ if (c === Char.u) parser.state = S.TRUE3;
+ else error(parser, 'Invalid true started with tr'+ c);
+ continue;
+
+ case S.TRUE3:
+ if(c === Char.e) {
+ emit(parser, "onvalue", true);
+ parser.state = parser.stack.pop() || S.VALUE;
+ } else error(parser, 'Invalid true started with tru'+ c);
+ continue;
+
+ case S.FALSE:
+ if (c === Char.a) parser.state = S.FALSE2;
+ else error(parser, 'Invalid false started with f'+ c);
+ continue;
+
+ case S.FALSE2:
+ if (c === Char.l) parser.state = S.FALSE3;
+ else error(parser, 'Invalid false started with fa'+ c);
+ continue;
+
+ case S.FALSE3:
+ if (c === Char.s) parser.state = S.FALSE4;
+ else error(parser, 'Invalid false started with fal'+ c);
+ continue;
+
+ case S.FALSE4:
+ if (c === Char.e) {
+ emit(parser, "onvalue", false);
+ parser.state = parser.stack.pop() || S.VALUE;
+ } else error(parser, 'Invalid false started with fals'+ c);
+ continue;
+
+ case S.NULL:
+ if (c === Char.u) parser.state = S.NULL2;
+ else error(parser, 'Invalid null started with n'+ c);
+ continue;
+
+ case S.NULL2:
+ if (c === Char.l) parser.state = S.NULL3;
+ else error(parser, 'Invalid null started with nu'+ c);
+ continue;
+
+ case S.NULL3:
+ if(c === Char.l) {
+ emit(parser, "onvalue", null);
+ parser.state = parser.stack.pop() || S.VALUE;
+ } else error(parser, 'Invalid null started with nul'+ c);
+ continue;
+
+ case S.NUMBER_DECIMAL_POINT:
+ if(c === Char.period) {
+ parser.numberNode += ".";
+ parser.state = S.NUMBER_DIGIT;
+ } else error(parser, 'Leading zero not followed by .');
+ continue;
+
+ case S.NUMBER_DIGIT:
+ if(Char._0 <= c && c <= Char._9) parser.numberNode += String.fromCharCode(c);
+ else if (c === Char.period) {
+ if(parser.numberNode.indexOf('.')!==-1)
+ error(parser, 'Invalid number has two dots');
+ parser.numberNode += ".";
+ } else if (c === Char.e || c === Char.E) {
+ if(parser.numberNode.indexOf('e')!==-1 ||
+ parser.numberNode.indexOf('E')!==-1 )
+ error(parser, 'Invalid number has two exponential');
+ parser.numberNode += "e";
+ } else if (c === Char.plus || c === Char.minus) {
+ if(!(p === Char.e || p === Char.E))
+ error(parser, 'Invalid symbol in number');
+ parser.numberNode += String.fromCharCode(c);
+ } else {
+ closeNumber(parser);
+ i--; // go back one
+ parser.state = parser.stack.pop() || S.VALUE;
+ }
+ continue;
+
+ default:
+ error(parser, "Unknown state: " + parser.state);
+ }
+ }
+ if (parser.position >= parser.bufferCheckPosition)
+ checkBufferLength(parser);
+ return parser;
+ }
+
+ })(exports);
+ });
+
+ function JsonStream(blob) {
+ var pos = 0;
+ var parser = JsonParser(true);
+ var rv = {
+ pullAsync: function (numBytes) {
+ return __awaiter(this, void 0, void 0, function () {
+ var slize, jsonPart, result;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ slize = blob.slice(pos, pos + numBytes);
+ pos += numBytes;
+ return [4 /*yield*/, readBlobAsync(slize, 'text')];
+ case 1:
+ jsonPart = _a.sent();
+ result = parser.write(jsonPart);
+ rv.result = result || {};
+ return [2 /*return*/, result];
+ }
+ });
+ });
+ },
+ pullSync: function (numBytes) {
+ var slize = blob.slice(pos, pos + numBytes);
+ pos += numBytes;
+ var jsonPart = readBlobSync(slize, 'text');
+ var result = parser.write(jsonPart);
+ rv.result = result || {};
+ return result;
+ },
+ done: function () {
+ return parser.done();
+ },
+ eof: function () {
+ return pos >= blob.size;
+ },
+ result: {}
+ };
+ return rv;
+ }
+ function JsonParser(allowPartial) {
+ var parser = clarinet_1.parser();
+ var level = 0;
+ var result;
+ var stack = [];
+ var obj;
+ var key;
+ var done = false;
+ var array = false;
+ parser.onopenobject = function (newKey) {
+ var newObj = {};
+ newObj.incomplete = true;
+ if (!result)
+ result = newObj;
+ if (obj) {
+ stack.push([key, obj, array]);
+ if (allowPartial) {
+ if (array) {
+ obj.push(newObj);
+ }
+ else {
+ obj[key] = newObj;
+ }
+ }
+ }
+ obj = newObj;
+ key = newKey;
+ array = false;
+ ++level;
+ };
+ parser.onkey = function (newKey) { return key = newKey; };
+ parser.onvalue = function (value) { return array ? obj.push(value) : obj[key] = value; };
+ parser.oncloseobject = function () {
+ var _a;
+ delete obj.incomplete;
+ key = null;
+ if (--level === 0) {
+ done = true;
+ }
+ else {
+ var completedObj = obj;
+ _a = stack.pop(), key = _a[0], obj = _a[1], array = _a[2];
+ if (!allowPartial) {
+ if (array) {
+ obj.push(completedObj);
+ }
+ else {
+ obj[key] = completedObj;
+ }
+ }
+ }
+ };
+ parser.onopenarray = function () {
+ var newObj = [];
+ newObj.incomplete = true;
+ if (!result)
+ result = newObj;
+ if (obj) {
+ stack.push([key, obj, array]);
+ if (allowPartial) {
+ if (array) {
+ obj.push(newObj);
+ }
+ else {
+ obj[key] = newObj;
+ }
+ }
+ }
+ obj = newObj;
+ array = true;
+ key = null;
+ ++level;
+ };
+ parser.onclosearray = function () {
+ var _a;
+ delete obj.incomplete;
+ key = null;
+ if (--level === 0) {
+ done = true;
+ }
+ else {
+ var completedObj = obj;
+ _a = stack.pop(), key = _a[0], obj = _a[1], array = _a[2];
+ if (!allowPartial) {
+ if (array) {
+ obj.push(completedObj);
+ }
+ else {
+ obj[key] = completedObj;
+ }
+ }
+ }
+ };
+ return {
+ write: function (jsonPart) {
+ parser.write(jsonPart);
+ return result;
+ },
+ done: function () {
+ return done;
+ }
+ };
+ }
+
+ var DEFAULT_KILOBYTES_PER_CHUNK = 1024;
+ function importDB(exportedData, options) {
+ return __awaiter(this, void 0, void 0, function () {
+ var CHUNK_SIZE, stream, dbExport, db;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ options = options || {}; // All booleans defaults to false.
+ CHUNK_SIZE = options.chunkSizeBytes || (DEFAULT_KILOBYTES_PER_CHUNK * 1024);
+ return [4 /*yield*/, loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE)];
+ case 1:
+ stream = _a.sent();
+ dbExport = stream.result.data;
+ db = new Dexie__default["default"](dbExport.databaseName);
+ db.version(dbExport.databaseVersion).stores(extractDbSchema(dbExport));
+ return [4 /*yield*/, importInto(db, stream, options)];
+ case 2:
+ _a.sent();
+ return [2 /*return*/, db];
+ }
+ });
+ });
+ }
+ function peakImportFile(exportedData) {
+ return __awaiter(this, void 0, void 0, function () {
+ var stream;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ stream = JsonStream(exportedData);
+ _a.label = 1;
+ case 1:
+ if (!!stream.eof()) return [3 /*break*/, 3];
+ return [4 /*yield*/, stream.pullAsync(5 * 1024)];
+ case 2:
+ _a.sent(); // 5 k is normally enough for the headers. If not, it will just do another go.
+ if (stream.result.data && stream.result.data.data) {
+ // @ts-ignore - TS won't allow us to delete a required property - but we are going to cast it.
+ delete stream.result.data.data; // Don't return half-baked data array.
+ return [3 /*break*/, 3];
+ }
+ return [3 /*break*/, 1];
+ case 3: return [2 /*return*/, stream.result];
+ }
+ });
+ });
+ }
+ function importInto(db, exportedData, options) {
+ return __awaiter(this, void 0, void 0, function () {
+ function importAll() {
+ return __awaiter(this, void 0, void 0, function () {
+ var _loop_1, _i, _a, tableExport, state_1;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ _loop_1 = function (tableExport) {
+ var tableName, table, tableSchemaStr, sourceRows, rows, i, obj, filter, filteredRows, _c, keys, values;
+ return __generator(this, function (_d) {
+ switch (_d.label) {
+ case 0:
+ if (!tableExport.rows)
+ return [2 /*return*/, "break"]; // Need to pull more!
+ if (!tableExport.rows.incomplete && tableExport.rows.length === 0)
+ return [2 /*return*/, "continue"];
+ if (progressCallback) {
+ // Keep ongoing transaction private
+ Dexie__default["default"].ignoreTransaction(function () { return progressCallback(progress); });
+ }
+ tableName = tableExport.tableName;
+ table = db.table(tableName);
+ tableSchemaStr = dbExport.tables.filter(function (t) { return t.name === tableName; })[0].schema;
+ if (!table) {
+ if (!options.acceptMissingTables)
+ throw new Error("Exported table ".concat(tableExport.tableName, " is missing in installed database"));
+ else
+ return [2 /*return*/, "continue"];
+ }
+ if (!options.acceptChangedPrimaryKey &&
+ tableSchemaStr.split(',')[0] != table.schema.primKey.src) {
+ throw new Error("Primary key differs for table ".concat(tableExport.tableName, ". "));
+ }
+ sourceRows = tableExport.rows;
+ rows = [];
+ for (i = 0; i < sourceRows.length; i++) {
+ obj = sourceRows[i];
+ if (!obj.incomplete) {
+ rows.push(TSON.revive(obj));
+ }
+ else {
+ break;
+ }
+ }
+ filter = options.filter;
+ filteredRows = filter ?
+ tableExport.inbound ?
+ rows.filter(function (value) { return filter(tableName, value); }) :
+ rows.filter(function (_a) {
+ var key = _a[0], value = _a[1];
+ return filter(tableName, value, key);
+ }) :
+ rows;
+ _c = tableExport.inbound ?
+ [undefined, filteredRows] :
+ [filteredRows.map(function (row) { return row[0]; }), rows.map(function (row) { return row[1]; })], keys = _c[0], values = _c[1];
+ if (!options.overwriteValues) return [3 /*break*/, 2];
+ return [4 /*yield*/, table.bulkPut(values, keys)];
+ case 1:
+ _d.sent();
+ return [3 /*break*/, 4];
+ case 2: return [4 /*yield*/, table.bulkAdd(values, keys)];
+ case 3:
+ _d.sent();
+ _d.label = 4;
+ case 4:
+ progress.completedRows += rows.length;
+ if (!rows.incomplete) {
+ progress.completedTables += 1;
+ }
+ sourceRows.splice(0, rows.length); // Free up RAM, keep existing array instance.
+ return [2 /*return*/];
+ }
+ });
+ };
+ _i = 0, _a = dbExport.data;
+ _b.label = 1;
+ case 1:
+ if (!(_i < _a.length)) return [3 /*break*/, 4];
+ tableExport = _a[_i];
+ return [5 /*yield**/, _loop_1(tableExport)];
+ case 2:
+ state_1 = _b.sent();
+ if (state_1 === "break")
+ return [3 /*break*/, 4];
+ _b.label = 3;
+ case 3:
+ _i++;
+ return [3 /*break*/, 1];
+ case 4:
+ // Avoid unnescessary loops in "for (const tableExport of dbExport.data)"
+ while (dbExport.data.length > 0 && dbExport.data[0].rows && !dbExport.data[0].rows.incomplete) {
+ // We've already imported all rows from the first table. Delete its occurrence
+ dbExport.data.splice(0, 1);
+ }
+ if (!(!jsonStream.done() && !jsonStream.eof())) return [3 /*break*/, 8];
+ if (!readBlobsSynchronously) return [3 /*break*/, 5];
+ // If we can pull from blob synchronically, we don't have to
+ // keep transaction alive using Dexie.waitFor().
+ // This will only be possible in workers.
+ jsonStream.pullSync(CHUNK_SIZE);
+ return [3 /*break*/, 7];
+ case 5: return [4 /*yield*/, Dexie__default["default"].waitFor(jsonStream.pullAsync(CHUNK_SIZE))];
+ case 6:
+ _b.sent();
+ _b.label = 7;
+ case 7: return [3 /*break*/, 9];
+ case 8: return [3 /*break*/, 10];
+ case 9:
+ return [3 /*break*/, 0];
+ case 10: return [2 /*return*/];
+ }
+ });
+ });
+ }
+ var CHUNK_SIZE, jsonStream, dbExportFile, readBlobsSynchronously, dbExport, progressCallback, progress, _i, _a, table;
+ return __generator(this, function (_b) {
+ switch (_b.label) {
+ case 0:
+ options = options || {}; // All booleans defaults to false.
+ CHUNK_SIZE = options.chunkSizeBytes || (DEFAULT_KILOBYTES_PER_CHUNK * 1024);
+ return [4 /*yield*/, loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE)];
+ case 1:
+ jsonStream = _b.sent();
+ dbExportFile = jsonStream.result;
+ readBlobsSynchronously = 'FileReaderSync' in self;
+ dbExport = dbExportFile.data;
+ if (!options.acceptNameDiff && db.name !== dbExport.databaseName)
+ throw new Error("Name differs. Current database name is ".concat(db.name, " but export is ").concat(dbExport.databaseName));
+ if (!options.acceptVersionDiff && db.verno !== dbExport.databaseVersion) {
+ // Possible feature: Call upgraders in some isolated way if this happens... ?
+ throw new Error("Database version differs. Current database is in version ".concat(db.verno, " but export is ").concat(dbExport.databaseVersion));
+ }
+ progressCallback = options.progressCallback;
+ progress = {
+ done: false,
+ completedRows: 0,
+ completedTables: 0,
+ totalRows: dbExport.tables.reduce(function (p, c) { return p + c.rowCount; }, 0),
+ totalTables: dbExport.tables.length
+ };
+ if (progressCallback) {
+ // Keep ongoing transaction private
+ Dexie__default["default"].ignoreTransaction(function () { return progressCallback(progress); });
+ }
+ if (!options.clearTablesBeforeImport) return [3 /*break*/, 5];
+ _i = 0, _a = db.tables;
+ _b.label = 2;
+ case 2:
+ if (!(_i < _a.length)) return [3 /*break*/, 5];
+ table = _a[_i];
+ return [4 /*yield*/, table.clear()];
+ case 3:
+ _b.sent();
+ _b.label = 4;
+ case 4:
+ _i++;
+ return [3 /*break*/, 2];
+ case 5:
+ if (!options.noTransaction) return [3 /*break*/, 7];
+ return [4 /*yield*/, importAll()];
+ case 6:
+ _b.sent();
+ return [3 /*break*/, 9];
+ case 7: return [4 /*yield*/, db.transaction('rw', db.tables, importAll)];
+ case 8:
+ _b.sent();
+ _b.label = 9;
+ case 9:
+ progress.done = true;
+ if (progressCallback) {
+ // Keep ongoing transaction private
+ Dexie__default["default"].ignoreTransaction(function () { return progressCallback(progress); });
+ }
+ return [2 /*return*/];
+ }
+ });
+ });
+ }
+ function loadUntilWeGotEnoughData(exportedData, CHUNK_SIZE) {
+ return __awaiter(this, void 0, void 0, function () {
+ var stream, dbExportFile;
+ return __generator(this, function (_a) {
+ switch (_a.label) {
+ case 0:
+ stream = ('slice' in exportedData ?
+ JsonStream(exportedData) :
+ exportedData);
+ _a.label = 1;
+ case 1:
+ if (!!stream.eof()) return [3 /*break*/, 3];
+ return [4 /*yield*/, stream.pullAsync(CHUNK_SIZE)];
+ case 2:
+ _a.sent();
+ if (stream.result.data && stream.result.data.data)
+ return [3 /*break*/, 3];
+ return [3 /*break*/, 1];
+ case 3:
+ dbExportFile = stream.result;
+ if (!dbExportFile || dbExportFile.formatName != "dexie")
+ throw new Error("Given file is not a dexie export");
+ if (dbExportFile.formatVersion > VERSION) {
+ throw new Error("Format version ".concat(dbExportFile.formatVersion, " not supported"));
+ }
+ if (!dbExportFile.data) {
+ throw new Error("No data in export file");
+ }
+ if (!dbExportFile.data.databaseName) {
+ throw new Error("Missing databaseName in export file");
+ }
+ if (!dbExportFile.data.databaseVersion) {
+ throw new Error("Missing databaseVersion in export file");
+ }
+ if (!dbExportFile.data.tables) {
+ throw new Error("Missing tables in export file");
+ }
+ return [2 /*return*/, stream];
+ }
+ });
+ });
+ }
+
+ //
+ // Extend Dexie interface (runtime wise)
+ //
+ Dexie__default["default"].prototype.export = function (options) {
+ return exportDB(this, options);
+ };
+ Dexie__default["default"].prototype.import = function (blob, options) {
+ return importInto(this, blob, options);
+ };
+ Dexie__default["default"].import = function (blob, options) { return importDB(blob, options); };
+ var dexieExportImport = (function () {
+ throw new Error("This addon extends Dexie.prototype globally and does not have be included in Dexie constructor's addons options.");
+ });
+
+ exports["default"] = dexieExportImport;
+ exports.exportDB = exportDB;
+ exports.importDB = importDB;
+ exports.importInto = importInto;
+ exports.peakImportFile = peakImportFile;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=dexie-export-import.js.map