dexie-export-import
Version:
Dexie addon that adds export and import capabilities
1 lines • 385 kB
Source Map (JSON)
{"version":3,"file":"dexie-export-import.mjs","sources":["../../../node_modules/.pnpm/tslib@2.3.1/node_modules/tslib/tslib.es6.js","../src/helpers.ts","../../../node_modules/.pnpm/typeson@5.18.2_iz6lblx3cjm7v34nvvsjg2rl44/node_modules/typeson/dist/typeson.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/node_modules/typeson/dist/typeson-esm.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/node_modules/base64-arraybuffer-es6/dist/base64-arraybuffer-es.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/user-object.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/presets/array-nonindex-keys.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/undef.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/primitive-objects.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/presets/special-numbers.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/nan.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/infinity.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/negative-infinity.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/date.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/regexp.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/map.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/set.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/arraybuffer.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/typed-arrays.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/dataview.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/intl-types.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/utils/stringArrayBuffer.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/file.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/bigint.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/bigint-object.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/cryptokey.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/presets/structured-cloning.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/imagedata.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/imagebitmap.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/filelist.js","../../../node_modules/.pnpm/typeson-registry@1.0.0-alpha.39/node_modules/typeson-registry/types/blob.js","../../../node_modules/.pnpm/base64-arraybuffer-es6@1.0.0/node_modules/base64-arraybuffer-es6/dist/base64-arraybuffer-es.js","../src/tson-typed-array.ts","../src/tson-arraybuffer.ts","../src/tson.ts","../src/export.ts","../src/json-structure.ts","../tools/build-configs/fake-stream.js","../../../node_modules/.pnpm/github.com+dfahlander+clarinet@d1dc89f7e67488b16ad98b2464d29a9b3bc6f5ef/node_modules/clarinet/clarinet.js","../src/json-stream.ts","../src/import.ts","../src/dexie-export-import.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (_) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","import Dexie from 'dexie';\nimport { DexieExportedDatabase } from './json-structure';\n\nexport function getSchemaString(table: Dexie.Table<any, any>) {\n const primKeyAndIndexes = [table.schema.primKey].concat(table.schema.indexes);\n return primKeyAndIndexes.map(index => index.src).join(',');\n}\n\nexport function extractDbSchema(exportedDb: DexieExportedDatabase) {\n const schema: {\n [tableName: string]: string;\n } = {};\n for (const table of exportedDb.tables) {\n schema[table.name] = table.schema;\n }\n return schema;\n}\n\n\n// Missing FileReaderSync type in standard typescript libs:\ninterface FileReaderSync {\n readAsArrayBuffer(blob: Blob): ArrayBuffer;\n readAsBinaryString(blob: Blob): string;\n readAsDataURL(blob: Blob): string;\n readAsText(blob: Blob, encoding?: string): string;\n}\ndeclare var FileReaderSync: {\n prototype: FileReaderSync;\n new(): FileReaderSync;\n};\n// -----------------------------------------------\n\nexport interface TypeMapper {\n binary: ArrayBuffer;\n text: string;\n}\n\nexport function readBlobAsync<T extends keyof TypeMapper>(blob: Blob, type: T): Promise<TypeMapper[T]> {\n return new Promise<TypeMapper[T]>((resolve, reject) => {\n const reader = new FileReader();\n reader.onabort = ev => reject(new Error(\"file read aborted\"));\n reader.onerror = ev => reject((ev.target as any).error);\n reader.onload = ev => resolve((ev.target as any).result);\n if (type === 'binary')\n reader.readAsArrayBuffer(blob);\n else\n reader.readAsText(blob);\n });\n}\n\nexport function readBlobSync<T extends keyof TypeMapper>(blob: Blob, type: T): TypeMapper[T] {\n if (typeof FileReaderSync === 'undefined') {\n 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.');\n }\n const reader = new FileReaderSync(); // Requires worker environment\n const data = type === 'binary' ?\n reader.readAsArrayBuffer(blob) :\n reader.readAsText(blob);\n\n return data as TypeMapper[T];\n}\n","(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global = global || self, global.Typeson = factory());\n}(this, (function () { 'use strict';\n\n function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n }\n\n function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n try {\n var info = gen[key](arg);\n var value = info.value;\n } catch (error) {\n reject(error);\n return;\n }\n\n if (info.done) {\n resolve(value);\n } else {\n Promise.resolve(value).then(_next, _throw);\n }\n }\n\n function _asyncToGenerator(fn) {\n return function () {\n var self = this,\n args = arguments;\n return new Promise(function (resolve, reject) {\n var gen = fn.apply(self, args);\n\n function _next(value) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n }\n\n function _throw(err) {\n asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n }\n\n _next(undefined);\n });\n };\n }\n\n function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n }\n\n function _defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n }\n\n function _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n }\n\n function _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n }\n\n function ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n keys.push.apply(keys, symbols);\n }\n\n return keys;\n }\n\n function _objectSpread2(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function (key) {\n _defineProperty(target, key, source[key]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n });\n }\n }\n\n return target;\n }\n\n function _slicedToArray(arr, i) {\n return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();\n }\n\n function _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();\n }\n\n function _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n\n return arr2;\n }\n }\n\n function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n }\n\n function _iterableToArray(iter) {\n if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter);\n }\n\n function _iterableToArrayLimit(arr, i) {\n if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === \"[object Arguments]\")) {\n return;\n }\n\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n\n return _arr;\n }\n\n function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n }\n\n function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n }\n\n /**\n * We keep this function minimized so if using two instances of this\n * library, where one is minimized and one is not, it will still work\n * with `hasConstructorOf`.\n * With ES6 classes, we may be able to simply use `class TypesonPromise\n * extends Promise` and add a string tag for detection.\n * @param {function} f\n */\n // eslint-disable-next-line max-len\n // eslint-disable-next-line block-spacing, space-before-function-paren, space-before-blocks, space-infix-ops, semi, promise/avoid-new\n var TypesonPromise = function TypesonPromise(f) {\n _classCallCheck(this, TypesonPromise);\n\n this.p = new Promise(f);\n }; // eslint-disable-next-line max-len\n // class TypesonPromise extends Promise {get[Symbol.toStringTag](){return 'TypesonPromise'};} // eslint-disable-line keyword-spacing, space-before-function-paren, space-before-blocks, block-spacing, semi\n\n\n TypesonPromise.__typeson__type__ = 'TypesonPromise'; // Note: core-js-bundle provides a `Symbol` polyfill\n\n /* istanbul ignore else */\n\n if (typeof Symbol !== 'undefined') {\n // Ensure `isUserObject` will return `false` for `TypesonPromise`\n TypesonPromise.prototype[Symbol.toStringTag] = 'TypesonPromise';\n }\n /**\n *\n * @param {function} [onFulfilled]\n * @param {function} [onRejected]\n * @returns {TypesonPromise}\n */\n\n\n TypesonPromise.prototype.then = function (onFulfilled, onRejected) {\n var _this = this;\n\n return new TypesonPromise(function (typesonResolve, typesonReject) {\n // eslint-disable-next-line promise/catch-or-return\n _this.p.then(function (res) {\n // eslint-disable-next-line promise/always-return\n typesonResolve(onFulfilled ? onFulfilled(res) : res);\n })[\"catch\"](function (res) {\n return onRejected ? onRejected(res) : Promise.reject(res);\n }).then(typesonResolve, typesonReject);\n });\n };\n /**\n *\n * @param {function} onRejected\n * @returns {TypesonPromise}\n */\n\n\n TypesonPromise.prototype[\"catch\"] = function (onRejected) {\n return this.then(null, onRejected);\n };\n /**\n *\n * @param {Any} v\n * @returns {TypesonPromise}\n */\n\n\n TypesonPromise.resolve = function (v) {\n return new TypesonPromise(function (typesonResolve) {\n typesonResolve(v);\n });\n };\n /**\n *\n * @param {Any} v\n * @returns {TypesonPromise}\n */\n\n\n TypesonPromise.reject = function (v) {\n return new TypesonPromise(function (typesonResolve, typesonReject) {\n typesonReject(v);\n });\n };\n\n ['all', 'race'].forEach(function (meth) {\n /**\n *\n * @param {Promise[]} promArr\n * @returns {TypesonPromise}\n */\n TypesonPromise[meth] = function (promArr) {\n return new TypesonPromise(function (typesonResolve, typesonReject) {\n // eslint-disable-next-line promise/catch-or-return\n Promise[meth](promArr.map(function (prom) {\n return prom && prom.constructor && prom.constructor.__typeson__type__ === 'TypesonPromise' ? prom.p : prom;\n })).then(typesonResolve, typesonReject);\n });\n };\n });\n\n var _ref = {},\n toStr = _ref.toString,\n hasOwn = {}.hasOwnProperty,\n getProto = Object.getPrototypeOf,\n fnToString = hasOwn.toString;\n /**\n * Second argument not in use internally, but provided for utility.\n * @param {Any} v\n * @param {boolean} catchCheck\n * @returns {boolean}\n */\n\n function isThenable(v, catchCheck) {\n return isObject(v) && typeof v.then === 'function' && (!catchCheck || typeof v[\"catch\"] === 'function');\n }\n /**\n *\n * @param {Any} val\n * @returns {string}\n */\n\n\n function toStringTag(val) {\n return toStr.call(val).slice(8, -1);\n }\n /**\n * This function is dependent on both constructors\n * being identical so any minimization is expected of both.\n * @param {Any} a\n * @param {function} b\n * @returns {boolean}\n */\n\n\n function hasConstructorOf(a, b) {\n if (!a || _typeof(a) !== 'object') {\n return false;\n }\n\n var proto = getProto(a);\n\n if (!proto) {\n return b === null;\n }\n\n var Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;\n\n if (typeof Ctor !== 'function') {\n return b === null;\n }\n\n if (b === Ctor) {\n return true;\n }\n\n if (b !== null && fnToString.call(Ctor) === fnToString.call(b)) {\n return true;\n }\n\n if (typeof b === 'function' && typeof Ctor.__typeson__type__ === 'string' && Ctor.__typeson__type__ === b.__typeson__type__) {\n return true;\n }\n\n return false;\n }\n /**\n *\n * @param {Any} val\n * @returns {boolean}\n */\n\n\n function isPlainObject(val) {\n // Mirrors jQuery's\n if (!val || toStringTag(val) !== 'Object') {\n return false;\n }\n\n var proto = getProto(val);\n\n if (!proto) {\n // `Object.create(null)`\n return true;\n }\n\n return hasConstructorOf(val, Object);\n }\n /**\n *\n * @param {Any} val\n * @returns {boolean}\n */\n\n\n function isUserObject(val) {\n if (!val || toStringTag(val) !== 'Object') {\n return false;\n }\n\n var proto = getProto(val);\n\n if (!proto) {\n // `Object.create(null)`\n return true;\n }\n\n return hasConstructorOf(val, Object) || isUserObject(proto);\n }\n /**\n *\n * @param {Any} v\n * @returns {boolean}\n */\n\n\n function isObject(v) {\n return v && _typeof(v) === 'object';\n }\n /**\n *\n * @param {string} keyPathComponent\n * @returns {string}\n */\n\n\n function escapeKeyPathComponent(keyPathComponent) {\n return keyPathComponent.replace(/~/g, '~0').replace(/\\./g, '~1');\n }\n /**\n *\n * @param {string} keyPathComponent\n * @returns {string}\n */\n\n\n function unescapeKeyPathComponent(keyPathComponent) {\n return keyPathComponent.replace(/~1/g, '.').replace(/~0/g, '~');\n }\n /**\n * @param {PlainObject|GenericArray} obj\n * @param {string} keyPath\n * @returns {Any}\n */\n\n\n function getByKeyPath(obj, keyPath) {\n if (keyPath === '') {\n return obj;\n }\n\n var period = keyPath.indexOf('.');\n\n if (period > -1) {\n var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];\n return innerObj === undefined ? undefined : getByKeyPath(innerObj, keyPath.slice(period + 1));\n }\n\n return obj[unescapeKeyPathComponent(keyPath)];\n }\n /**\n *\n * @param {PlainObject} obj\n * @param {string} keyPath\n * @param {Any} value\n * @returns {Any}\n */\n\n\n function setAtKeyPath(obj, keyPath, value) {\n if (keyPath === '') {\n return value;\n }\n\n var period = keyPath.indexOf('.');\n\n if (period > -1) {\n var innerObj = obj[unescapeKeyPathComponent(keyPath.slice(0, period))];\n return setAtKeyPath(innerObj, keyPath.slice(period + 1), value);\n }\n\n obj[unescapeKeyPathComponent(keyPath)] = value;\n return obj;\n }\n /**\n *\n * @param {external:JSON} value\n * @returns {\"null\"|\"array\"|\"undefined\"|\"boolean\"|\"number\"|\"string\"|\n * \"object\"|\"symbol\"}\n */\n\n\n function getJSONType(value) {\n return value === null ? 'null' : Array.isArray(value) ? 'array' : _typeof(value);\n }\n\n var keys = Object.keys,\n isArray = Array.isArray,\n hasOwn$1 = {}.hasOwnProperty,\n internalStateObjPropsToIgnore = ['type', 'replaced', 'iterateIn', 'iterateUnsetNumeric'];\n /**\n * Handle plain object revivers first so reference setting can use\n * revived type (e.g., array instead of object); assumes revived\n * has same structure or will otherwise break subsequent references.\n * @param {PlainObjectType} a\n * @param {PlainObjectType} b\n * @returns {1|-1|boolean}\n */\n\n function nestedPathsFirst(a, b) {\n if (a.keypath === '') {\n return -1;\n }\n\n var as = a.keypath.match(/\\./g) || 0;\n var bs = b.keypath.match(/\\./g) || 0;\n\n if (as) {\n as = as.length;\n }\n\n if (bs) {\n bs = bs.length;\n }\n\n return as > bs ? -1 : as < bs ? 1 : a.keypath < b.keypath ? -1 : a.keypath > b.keypath;\n }\n /**\n * An instance of this class can be used to call `stringify()` and `parse()`.\n * Typeson resolves cyclic references by default. Can also be extended to\n * support custom types using the register() method.\n *\n * @class\n * @param {{cyclic: boolean}} [options] - if cyclic (default true),\n * cyclic references will be handled gracefully.\n */\n\n\n var Typeson =\n /*#__PURE__*/\n function () {\n function Typeson(options) {\n _classCallCheck(this, Typeson);\n\n this.options = options; // Replacers signature: replace (value). Returns falsy if not\n // replacing. Otherwise ['Date', value.getTime()]\n\n this.plainObjectReplacers = [];\n this.nonplainObjectReplacers = []; // Revivers: [{type => reviver}, {plain: boolean}].\n // Sample: [{'Date': value => new Date(value)}, {plain: false}]\n\n this.revivers = {};\n /** Types registered via `register()`. */\n\n this.types = {};\n }\n /**\n * @typedef {null|boolean|number|string|GenericArray|PlainObject} JSON\n */\n\n /**\n * @callback JSONReplacer\n * @param {\"\"|string} key\n * @param {JSON} value\n * @returns {number|string|boolean|null|PlainObject|undefined}\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The%20replacer%20parameter\n */\n\n /**\n * Serialize given object to Typeson.\n * Initial arguments work identical to those of `JSON.stringify`.\n * The `replacer` argument has nothing to do with our replacers.\n * @param {Any} obj\n * @param {JSONReplacer|string[]} replacer\n * @param {number|string} space\n * @param {object} opts\n * @returns {string|Promise} Promise resolves to a string\n */\n\n\n _createClass(Typeson, [{\n key: \"stringify\",\n value: function stringify(obj, replacer, space, opts) {\n opts = _objectSpread2({}, this.options, {}, opts, {\n stringification: true\n });\n var encapsulated = this.encapsulate(obj, null, opts);\n\n if (isArray(encapsulated)) {\n return JSON.stringify(encapsulated[0], replacer, space);\n }\n\n return encapsulated.then(function (res) {\n return JSON.stringify(res, replacer, space);\n });\n }\n /**\n * Also sync but throws on non-sync result.\n * @param {Any} obj\n * @param {JSONReplacer|string[]} replacer\n * @param {number|string} space\n * @param {object} opts\n * @returns {string}\n */\n\n }, {\n key: \"stringifySync\",\n value: function stringifySync(obj, replacer, space, opts) {\n return this.stringify(obj, replacer, space, _objectSpread2({\n throwOnBadSyncType: true\n }, opts, {\n sync: true\n }));\n }\n /**\n *\n * @param {Any} obj\n * @param {JSONReplacer|string[]} replacer\n * @param {number|string} space\n * @param {object} opts\n * @returns {Promise<string>}\n */\n\n }, {\n key: \"stringifyAsync\",\n value: function stringifyAsync(obj, replacer, space, opts) {\n return this.stringify(obj, replacer, space, _objectSpread2({\n throwOnBadSyncType: true\n }, opts, {\n sync: false\n }));\n }\n /**\n * Parse Typeson back into an obejct.\n * Initial arguments works identical to those of `JSON.parse()`.\n * @param {string} text\n * @param {function} reviver This JSON reviver has nothing to do with\n * our revivers.\n * @param {object} opts\n * @returns {external:JSON}\n */\n\n }, {\n key: \"parse\",\n value: function parse(text, reviver, opts) {\n opts = _objectSpread2({}, this.options, {}, opts, {\n parse: true\n });\n return this.revive(JSON.parse(text, reviver), opts);\n }\n /**\n * Also sync but throws on non-sync result.\n * @param {string} text\n * @param {function} reviver This JSON reviver has nothing to do with\n * our revivers.\n * @param {object} opts\n * @returns {external:JSON}\n */\n\n }, {\n key: \"parseSync\",\n value: function parseSync(text, reviver, opts) {\n return this.parse(text, reviver, _objectSpread2({\n throwOnBadSyncType: true\n }, opts, {\n sync: true\n }));\n }\n /**\n * @param {string} text\n * @param {function} reviver This JSON reviver has nothing to do with\n * our revivers.\n * @param {object} opts\n * @returns {Promise} Resolves to `external:JSON`\n */\n\n }, {\n key: \"parseAsync\",\n value: function parseAsync(text, reviver, opts) {\n return this.parse(text, reviver, _objectSpread2({\n throwOnBadSyncType: true\n }, opts, {\n sync: false\n }));\n }\n /**\n *\n * @param {Any} obj\n * @param {object} stateObj\n * @param {object} [opts={}]\n * @returns {string[]|false}\n */\n\n }, {\n key: \"specialTypeNames\",\n value: function specialTypeNames(obj, stateObj) {\n var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n opts.returnTypeNames = true;\n return this.encapsulate(obj, stateObj, opts);\n }\n /**\n *\n * @param {Any} obj\n * @param {PlainObject} stateObj\n * @param {PlainObject} [opts={}]\n * @returns {Promise|GenericArray|PlainObject|string|false}\n */\n\n }, {\n key: \"rootTypeName\",\n value: function rootTypeName(obj, stateObj) {\n var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n opts.iterateNone = true;\n return this.encapsulate(obj, stateObj, opts);\n }\n /**\n * Encapsulate a complex object into a plain Object by replacing\n * registered types with plain objects representing the types data.\n *\n * This method is used internally by `Typeson.stringify()`.\n * @param {Any} obj - Object to encapsulate.\n * @param {PlainObject} stateObj\n * @param {PlainObject} opts\n * @returns {Promise|GenericArray|PlainObject|string|false}\n */\n\n }, {\n key: \"encapsulate\",\n value: function encapsulate(obj, stateObj, opts) {\n opts = _objectSpread2({\n sync: true\n }, this.options, {}, opts);\n var _opts = opts,\n sync = _opts.sync;\n var that = this,\n types = {},\n refObjs = [],\n // For checking cyclic references\n refKeys = [],\n // For checking cyclic references\n promisesDataRoot = []; // Clone the object deeply while at the same time replacing any\n // special types or cyclic reference:\n\n var cyclic = 'cyclic' in opts ? opts.cyclic : true;\n var _opts2 = opts,\n encapsulateObserver = _opts2.encapsulateObserver;\n\n var ret = _encapsulate('', obj, cyclic, stateObj || {}, promisesDataRoot);\n /**\n *\n * @param {Any} ret\n * @returns {GenericArray|PlainObject|string|false}\n */\n\n\n function finish(ret) {\n // Add `$types` to result only if we ever bumped into a\n // special type (or special case where object has own `$types`)\n var typeNames = Object.values(types);\n\n if (opts.iterateNone) {\n if (typeNames.length) {\n return typeNames[0];\n }\n\n return Typeson.getJSONType(ret);\n }\n\n if (typeNames.length) {\n if (opts.returnTypeNames) {\n return _toConsumableArray(new Set(typeNames));\n } // Special if array (or a primitive) was serialized\n // because JSON would ignore custom `$types` prop on it\n\n\n if (!ret || !isPlainObject(ret) || // Also need to handle if this is an object with its\n // own `$types` property (to avoid ambiguity)\n hasOwn$1.call(ret, '$types')) {\n ret = {\n $: ret,\n $types: {\n $: types\n }\n };\n } else {\n ret.$types = types;\n } // No special types\n\n } else if (isObject(ret) && hasOwn$1.call(ret, '$types')) {\n ret = {\n $: ret,\n $types: true\n };\n }\n\n if (opts.returnTypeNames) {\n return false;\n }\n\n return ret;\n }\n /**\n *\n * @param {Any} ret\n * @param {GenericArray} promisesData\n * @returns {Promise<Any>}\n */\n\n\n function checkPromises(_x, _x2) {\n return _checkPromises.apply(this, arguments);\n }\n /**\n *\n * @param {object} stateObj\n * @param {object} ownKeysObj\n * @param {function} cb\n * @returns {undefined}\n */\n\n\n function _checkPromises() {\n _checkPromises = _asyncToGenerator(\n /*#__PURE__*/\n regeneratorRuntime.mark(function _callee2(ret, promisesData) {\n var promResults;\n return regeneratorRuntime.wrap(function _callee2$(_context2) {\n while (1) {\n switch (_context2.prev = _context2.next) {\n case 0:\n _context2.next = 2;\n return Promise.all(promisesData.map(function (pd) {\n return pd[1].p;\n }));\n\n case 2:\n promResults = _context2.sent;\n _context2.next = 5;\n return Promise.all(promResults.map(\n /*#__PURE__*/\n function () {\n var _ref = _asyncToGenerator(\n /*#__PURE__*/\n regeneratorRuntime.mark(function _callee(promResult) {\n var newPromisesData, _promisesData$splice, _promisesData$splice2, prData, _prData, keyPath, cyclic, stateObj, parentObj, key, detectedType, encaps, isTypesonPromise, encaps2;\n\n return regeneratorRuntime.wrap(function _callee$(_context) {\n while (1) {\n switch (_context.prev = _context.next) {\n case 0:\n newPromisesData = [];\n _promisesData$splice = promisesData.splice(0, 1), _promisesData$splice2 = _slicedToArray(_promisesData$splice, 1), prData = _promisesData$splice2[0];\n _prData = _slicedToArray(prData, 7), keyPath = _prData[0], cyclic = _prData[2], stateObj = _prData[3], parentObj = _prData[4], key = _prData[5], detectedType = _prData[6];\n encaps = _encapsulate(keyPath, promResult, cyclic, stateObj, newPromisesData, true, detectedType);\n isTypesonPromise = hasConstructorOf(encaps, TypesonPromise); // Handle case where an embedded custom type itself\n // returns a `Typeson.Promise`\n\n if (!(keyPath && isTypesonPromise)) {\n _context.next = 11;\n break;\n }\n\n _context.next = 8;\n return encaps.p;\n\n case 8:\n encaps2 = _context.sent;\n parentObj[key] = encaps2;\n return _context.abrupt(\"return\", checkPromises(ret, newPromisesData));\n\n case 11:\n if (keyPath) {\n parentObj[key] = encaps;\n } else if (isTypesonPromise) {\n ret = encaps.p;\n } else {\n // If this is itself a `Typeson.Promise` (because the\n // original value supplied was a `Promise` or\n // because the supplied custom type value resolved\n // to one), returning it below will be fine since\n // a `Promise` is expected anyways given current\n // config (and if not a `Promise`, it will be ready\n // as the resolve value)\n ret = encaps;\n }\n\n return _context.abrupt(\"return\", checkPromises(ret, newPromisesData));\n\n case 13:\n case \"end\":\n return _context.stop();\n }\n }\n }, _callee);\n }));\n\n return function (_x3) {\n return _ref.apply(this, arguments);\n };\n }()));\n\n case 5:\n return _context2.abrupt(\"return\", ret);\n\n case 6:\n case \"end\":\n return _context2.stop();\n }\n }\n }, _callee2);\n }));\n return _checkPromises.apply(this, arguments);\n }\n\n function _adaptBuiltinStateObjectProperties(stateObj, ownKeysObj, cb) {\n Object.assign(stateObj, ownKeysObj);\n var vals = internalStateObjPropsToIgnore.map(function (prop) {\n var tmp = stateObj[prop];\n delete stateObj[prop];\n return tmp;\n }); // eslint-disable-next-line callback-return\n\n cb();\n internalStateObjPropsToIgnore.forEach(function (prop, i) {\n stateObj[prop] = vals[i];\n });\n }\n /**\n *\n * @param {string} keypath\n * @param {Any} value\n * @param {boolean} cyclic\n * @param {PlainObject} stateObj\n * @param {boolean} promisesData\n * @param {boolean} resolvingTypesonPromise\n * @param {string} detectedType\n * @returns {Any}\n */\n\n\n function _encapsulate(keypath, value, cyclic, stateObj, promisesData, resolvingTypesonPromise, detectedType) {\n var ret;\n var observerData = {};\n\n var $typeof = _typeof(value);\n\n var runObserver = encapsulateObserver ? function (obj) {\n var type = detectedType || stateObj.type || Typeson.getJSONType(value);\n encapsulateObserver(Object.assign(obj || observerData, {\n keypath: keypath,\n value: value,\n cyclic: cyclic,\n stateObj: stateObj,\n promisesData: promisesData,\n resolvingTypesonPromise: resolvingTypesonPromise,\n awaitingTypesonPromise: hasConstructorOf(value, TypesonPromise)\n }, {\n type: type\n }));\n } : null;\n\n if (['string', 'boolean', 'number', 'undefined'].includes($typeof)) {\n if (value === undefined || $typeof === 'number' && (isNaN(value) || value === -Infinity || value === Infinity)) {\n if (stateObj.replaced) {\n ret = value;\n } else {\n ret = replace(keypath, value, stateObj, promisesData, false, resolvingTypesonPromise, runObserver);\n }\n\n if (ret !== value) {\n observerData = {\n replaced: ret\n };\n }\n } else {\n ret = value;\n }\n\n if (runObserver) {\n runObserver();\n }\n\n return ret;\n }\n\n if (value === null) {\n if (runObserver) {\n runObserver();\n }\n\n return value;\n }\n\n if (cyclic && !stateObj.iterateIn && !stateObj.iterateUnsetNumeric && value && _typeof(value) === 'object') {\n // Options set to detect cyclic references and be able\n // to rewrite them.\n var refIndex = refObjs.indexOf(value);\n\n if (refIndex < 0) {\n if (cyclic === true) {\n refObjs.push(value);\n refKeys.push(keypath);\n }\n } else {\n types[keypath] = '#';\n\n if (runObserver) {\n runObserver({\n cyclicKeypath: refKeys[refIndex]\n });\n }\n\n return '#' + refKeys[refIndex];\n }\n }\n\n var isPlainObj = isPlainObject(value);\n var isArr = isArray(value);\n var replaced = // Running replace will cause infinite loop as will test\n // positive again\n (isPlainObj || isArr) && (!that.plainObjectReplacers.length || stateObj.replaced) || stateObj.iterateIn ? // Optimization: if plain object and no plain-object\n // replacers, don't try finding a replacer\n value : replace(keypath, value, stateObj, promisesData, isPlainObj || isArr, null, runObserver);\n var clone;\n\n if (replaced !== value) {\n ret = replac