@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/cjs/plugins/utils/utils-array.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayFilterNotEmpty = arrayFilterNotEmpty;
+exports.asyncFilter = asyncFilter;
+exports.batchArray = batchArray;
+exports.countUntilNotMatching = countUntilNotMatching;
+exports.isMaybeReadonlyArray = isMaybeReadonlyArray;
+exports.isOneItemOfArrayInOtherArray = isOneItemOfArrayInOtherArray;
+exports.lastOfArray = lastOfArray;
+exports.maxOfNumbers = maxOfNumbers;
+exports.randomOfArray = randomOfArray;
+exports.removeOneFromArrayIfMatches = removeOneFromArrayIfMatches;
+exports.shuffleArray = shuffleArray;
+exports.sortByObjectNumberProperty = sortByObjectNumberProperty;
+exports.sumNumberArray = sumNumberArray;
+exports.toArray = toArray;
+exports.uniqueArray = uniqueArray;
+function lastOfArray(ar) {
+  return ar[ar.length - 1];
+}
+
+/**
+ * shuffle the given array
+ */
+function shuffleArray(arr) {
+  return arr.slice(0).sort(() => Math.random() - 0.5);
+}
+function randomOfArray(arr) {
+  var randomElement = arr[Math.floor(Math.random() * arr.length)];
+  return randomElement;
+}
+function toArray(input) {
+  return Array.isArray(input) ? input.slice(0) : [input];
+}
+
+/**
+ * Split array with items into smaller arrays with items
+ * @link https://stackoverflow.com/a/7273794/3443137
+ */
+function batchArray(array, batchSize) {
+  array = array.slice(0);
+  var ret = [];
+  while (array.length) {
+    var batch = array.splice(0, batchSize);
+    ret.push(batch);
+  }
+  return ret;
+}
+
+/**
+ * @link https://stackoverflow.com/a/15996017
+ */
+function removeOneFromArrayIfMatches(ar, condition) {
+  ar = ar.slice();
+  var i = ar.length;
+  var done = false;
+  while (i-- && !done) {
+    if (condition(ar[i])) {
+      done = true;
+      ar.splice(i, 1);
+    }
+  }
+  return ar;
+}
+
+/**
+ * returns true if the supplied argument is either an Array<T> or a Readonly<Array<T>>
+ */
+function isMaybeReadonlyArray(x) {
+  // While this looks strange, it's a workaround for an issue in TypeScript:
+  // https://github.com/microsoft/TypeScript/issues/17002
+  //
+  // The problem is that `Array.isArray` as a type guard returns `false` for a readonly array,
+  // but at runtime the object is an array and the runtime call to `Array.isArray` would return `true`.
+  // The type predicate here allows for both `Array<T>` and `Readonly<Array<T>>` to pass a type check while
+  // still performing runtime type inspection.
+  return Array.isArray(x);
+}
+function isOneItemOfArrayInOtherArray(ar1, ar2) {
+  for (var i = 0; i < ar1.length; i++) {
+    var el = ar1[i];
+    var has = ar2.includes(el);
+    if (has) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Use this in array.filter() to remove all empty slots
+ * and have the correct typings afterwards.
+ * @link https://stackoverflow.com/a/46700791/3443137
+ */
+function arrayFilterNotEmpty(value) {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  return true;
+}
+function countUntilNotMatching(ar, matchingFn) {
+  var count = 0;
+  var idx = -1;
+  for (var item of ar) {
+    idx = idx + 1;
+    var matching = matchingFn(item, idx);
+    if (matching) {
+      count = count + 1;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+async function asyncFilter(array, predicate) {
+  var filters = await Promise.all(array.map(predicate));
+  return array.filter((...[, index]) => filters[index]);
+}
+
+/**
+ * @link https://stackoverflow.com/a/3762735
+ */
+function sumNumberArray(array) {
+  var count = 0;
+  for (var i = array.length; i--;) {
+    count += array[i];
+  }
+  return count;
+}
+function maxOfNumbers(arr) {
+  return Math.max(...arr);
+}
+
+/**
+ * @link https://gist.github.com/telekosmos/3b62a31a5c43f40849bb
+ */
+function uniqueArray(arrArg) {
+  return arrArg.filter(function (elem, pos, arr) {
+    return arr.indexOf(elem) === pos;
+  });
+}
+function sortByObjectNumberProperty(property) {
+  return (a, b) => {
+    return b[property] - a[property];
+  };
+}
+//# sourceMappingURL=utils-array.js.map

package/dist/cjs/plugins/utils/utils-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-array.js","names":["lastOfArray","ar","length","shuffleArray","arr","slice","sort","Math","random","randomOfArray","randomElement","floor","toArray","input","Array","isArray","batchArray","array","batchSize","ret","batch","splice","push","removeOneFromArrayIfMatches","condition","i","done","isMaybeReadonlyArray","x","isOneItemOfArrayInOtherArray","ar1","ar2","el","has","includes","arrayFilterNotEmpty","value","undefined","countUntilNotMatching","matchingFn","count","idx","item","matching","asyncFilter","predicate","filters","Promise","all","map","filter","index","sumNumberArray","maxOfNumbers","max","uniqueArray","arrArg","elem","pos","indexOf","sortByObjectNumberProperty","property","a","b"],"sources":["../../../../src/plugins/utils/utils-array.ts"],"sourcesContent":["import type {\r\n    MaybePromise,\r\n    MaybeReadonly\r\n} from '../../types/index.d.ts';\r\n\r\nexport function lastOfArray<T>(ar: T[]): T | undefined {\r\n    return ar[ar.length - 1];\r\n}\r\n\r\n/**\r\n * shuffle the given array\r\n */\r\nexport function shuffleArray<T>(arr: T[]): T[] {\r\n    return arr.slice(0).sort(() => (Math.random() - 0.5));\r\n}\r\n\r\nexport function randomOfArray<T>(arr: T[]): T {\r\n    const randomElement = arr[Math.floor(Math.random() * arr.length)];\r\n    return randomElement;\r\n}\r\n\r\n\r\nexport function toArray<T>(input: T | T[] | Readonly<T> | Readonly<T[]>): T[] {\r\n    return Array.isArray(input) ? (input as any[]).slice(0) : ([input] as any);\r\n}\r\n\r\n/**\r\n * Split array with items into smaller arrays with items\r\n * @link https://stackoverflow.com/a/7273794/3443137\r\n */\r\nexport function batchArray<T>(array: T[], batchSize: number): T[][] {\r\n    array = array.slice(0);\r\n    const ret: T[][] = [];\r\n    while (array.length) {\r\n        const batch = array.splice(0, batchSize);\r\n        ret.push(batch);\r\n    }\r\n    return ret;\r\n}\r\n\r\n/**\r\n * @link https://stackoverflow.com/a/15996017\r\n */\r\nexport function removeOneFromArrayIfMatches<T>(ar: T[], condition: (x: T) => boolean): T[] {\r\n    ar = ar.slice();\r\n    let i = ar.length;\r\n    let done = false;\r\n    while (i-- && !done) {\r\n        if (condition(ar[i])) {\r\n            done = true;\r\n            ar.splice(i, 1);\r\n        }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/**\r\n * returns true if the supplied argument is either an Array<T> or a Readonly<Array<T>>\r\n */\r\nexport function isMaybeReadonlyArray(x: any): x is MaybeReadonly<any[]> {\r\n    // While this looks strange, it's a workaround for an issue in TypeScript:\r\n    // https://github.com/microsoft/TypeScript/issues/17002\r\n    //\r\n    // The problem is that `Array.isArray` as a type guard returns `false` for a readonly array,\r\n    // but at runtime the object is an array and the runtime call to `Array.isArray` would return `true`.\r\n    // The type predicate here allows for both `Array<T>` and `Readonly<Array<T>>` to pass a type check while\r\n    // still performing runtime type inspection.\r\n    return Array.isArray(x);\r\n}\r\n\r\n\r\n\r\nexport function isOneItemOfArrayInOtherArray<T>(ar1: T[], ar2: T[]): boolean {\r\n    for (let i = 0; i < ar1.length; i++) {\r\n        const el = ar1[i];\r\n        const has = ar2.includes(el);\r\n        if (has) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\n\r\n\r\n/**\r\n * Use this in array.filter() to remove all empty slots\r\n * and have the correct typings afterwards.\r\n * @link https://stackoverflow.com/a/46700791/3443137\r\n */\r\nexport function arrayFilterNotEmpty<TValue>(value: TValue | null | undefined): value is TValue {\r\n    if (value === null || value === undefined) {\r\n        return false;\r\n    }\r\n    return true;\r\n}\r\n\r\nexport function countUntilNotMatching<T>(\r\n    ar: T[],\r\n    matchingFn: (v: T, idx: number) => boolean\r\n): number {\r\n    let count = 0;\r\n    let idx = -1;\r\n    for (const item of ar) {\r\n        idx = idx + 1;\r\n        const matching = matchingFn(item, idx);\r\n        if (matching) {\r\n            count = count + 1;\r\n        } else {\r\n            break;\r\n        }\r\n    }\r\n    return count;\r\n}\r\n\r\nexport async function asyncFilter<T>(array: T[], predicate: (item: T, index: number, a: T[]) => MaybePromise<boolean>): Promise<T[]> {\r\n    const filters = await Promise.all(\r\n        array.map(predicate)\r\n    );\r\n\r\n    return array.filter((...[, index]) => filters[index]);\r\n}\r\n\r\n/**\r\n * @link https://stackoverflow.com/a/3762735\r\n */\r\nexport function sumNumberArray(array: number[]): number {\r\n    let count = 0;\r\n    for (let i = array.length; i--;) {\r\n        count += array[i];\r\n    }\r\n    return count;\r\n}\r\n\r\nexport function maxOfNumbers(arr: number[]): number {\r\n    return Math.max(...arr);\r\n}\r\n\r\n/**\r\n * @link https://gist.github.com/telekosmos/3b62a31a5c43f40849bb\r\n */\r\nexport function uniqueArray(arrArg: string[]): string[] {\r\n    return arrArg.filter(function (elem, pos, arr) {\r\n        return arr.indexOf(elem) === pos;\r\n    });\r\n}\r\n\r\n\r\nexport function sortByObjectNumberProperty<T>(property: keyof T) {\r\n    return (a: T, b: T) => {\r\n        return (b as any)[property] - (a as any)[property];\r\n    }\r\n}\r\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-base64.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+exports.b64DecodeUnicode = b64DecodeUnicode;
+exports.b64EncodeUnicode = b64EncodeUnicode;
+exports.base64ToArrayBuffer = base64ToArrayBuffer;
+var _jsBase = require("js-base64");
+/**
+ * NO! We cannot just use btoa() and atob()
+ * because they do not work correctly with binary data.
+ * @link https://stackoverflow.com/q/30106476/3443137
+ */
+
+/**
+ * atob() and btoa() do not work well with non ascii chars,
+ * so we have to use these helper methods instead.
+ * @link https://stackoverflow.com/a/30106551/3443137
+ */
+// Encoding UTF8 -> base64
+function b64EncodeUnicode(str) {
+  return (0, _jsBase.encode)(str);
+}
+
+// Decoding base64 -> UTF8
+function b64DecodeUnicode(str) {
+  return (0, _jsBase.decode)(str);
+}
+
+/**
+ * @link https://stackoverflow.com/a/9458996/3443137
+ */
+function arrayBufferToBase64(buffer) {
+  var binary = '';
+  var bytes = new Uint8Array(buffer);
+  var len = bytes.byteLength;
+  for (var i = 0; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+/**
+ * @link https://stackoverflow.com/a/21797381
+ */
+function base64ToArrayBuffer(base64) {
+  var binary_string = atob(base64);
+  var len = binary_string.length;
+  var bytes = new Uint8Array(len);
+  for (var i = 0; i < len; i++) {
+    bytes[i] = binary_string.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+//# sourceMappingURL=utils-base64.js.map

package/dist/cjs/plugins/utils/utils-base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-base64.js","names":["_jsBase","require","b64EncodeUnicode","str","encode","b64DecodeUnicode","decode","arrayBufferToBase64","buffer","binary","bytes","Uint8Array","len","byteLength","i","String","fromCharCode","btoa","base64ToArrayBuffer","base64","binary_string","atob","length","charCodeAt"],"sources":["../../../../src/plugins/utils/utils-base64.ts"],"sourcesContent":["\r\n/**\r\n * NO! We cannot just use btoa() and atob()\r\n * because they do not work correctly with binary data.\r\n * @link https://stackoverflow.com/q/30106476/3443137\r\n */\r\nimport { encode, decode } from 'js-base64';\r\n\r\n/**\r\n * atob() and btoa() do not work well with non ascii chars,\r\n * so we have to use these helper methods instead.\r\n * @link https://stackoverflow.com/a/30106551/3443137\r\n */\r\n// Encoding UTF8 -> base64\r\nexport function b64EncodeUnicode(str: string) {\r\n    return encode(str);\r\n}\r\n\r\n// Decoding base64 -> UTF8\r\nexport function b64DecodeUnicode(str: string) {\r\n    return decode(str);\r\n}\r\n\r\n/**\r\n * @link https://stackoverflow.com/a/9458996/3443137\r\n */\r\nexport function arrayBufferToBase64(buffer: ArrayBuffer) {\r\n    let binary = '';\r\n    const bytes = new Uint8Array(buffer);\r\n    const len = bytes.byteLength;\r\n    for (let i = 0; i < len; i++) {\r\n        binary += String.fromCharCode(bytes[i]);\r\n    }\r\n    return btoa(binary);\r\n}\r\n\r\n\r\n/**\r\n * @link https://stackoverflow.com/a/21797381\r\n */\r\nexport function base64ToArrayBuffer(base64: string): ArrayBuffer {\r\n    const binary_string = atob(base64);\r\n    const len = binary_string.length;\r\n    const bytes = new Uint8Array(len);\r\n    for (let i = 0; i < len; i++) {\r\n        bytes[i] = binary_string.charCodeAt(i);\r\n    }\r\n    return bytes.buffer;\r\n}\r\n"],"mappings":";;;;;;;;;AAMA,IAAAA,OAAA,GAAAC,OAAA;AALA;AACA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,gBAAgBA,CAACC,GAAW,EAAE;EAC1C,OAAO,IAAAC,cAAM,EAACD,GAAG,CAAC;AACtB;;AAEA;AACO,SAASE,gBAAgBA,CAACF,GAAW,EAAE;EAC1C,OAAO,IAAAG,cAAM,EAACH,GAAG,CAAC;AACtB;;AAEA;AACA;AACA;AACO,SAASI,mBAAmBA,CAACC,MAAmB,EAAE;EACrD,IAAIC,MAAM,GAAG,EAAE;EACf,IAAMC,KAAK,GAAG,IAAIC,UAAU,CAACH,MAAM,CAAC;EACpC,IAAMI,GAAG,GAAGF,KAAK,CAACG,UAAU;EAC5B,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,GAAG,EAAEE,CAAC,EAAE,EAAE;IAC1BL,MAAM,IAAIM,MAAM,CAACC,YAAY,CAACN,KAAK,CAACI,CAAC,CAAC,CAAC;EAC3C;EACA,OAAOG,IAAI,CAACR,MAAM,CAAC;AACvB;;AAGA;AACA;AACA;AACO,SAASS,mBAAmBA,CAACC,MAAc,EAAe;EAC7D,IAAMC,aAAa,GAAGC,IAAI,CAACF,MAAM,CAAC;EAClC,IAAMP,GAAG,GAAGQ,aAAa,CAACE,MAAM;EAChC,IAAMZ,KAAK,GAAG,IAAIC,UAAU,CAACC,GAAG,CAAC;EACjC,KAAK,IAAIE,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,GAAG,EAAEE,CAAC,EAAE,EAAE;IAC1BJ,KAAK,CAACI,CAAC,CAAC,GAAGM,aAAa,CAACG,UAAU,CAACT,CAAC,CAAC;EAC1C;EACA,OAAOJ,KAAK,CAACF,MAAM;AACvB","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-blob.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.blobToBase64String = blobToBase64String;
+exports.blobToString = blobToString;
+exports.createBlob = createBlob;
+exports.createBlobFromBase64 = createBlobFromBase64;
+var _utilsBase = require("./utils-base64.js");
+/**
+ * Since RxDB 13.0.0 we only use Blob instead of falling back to Buffer,
+ * because Node.js >18 supports Blobs anyway.
+ */
+/**
+ * depending if we are on node or browser,
+ * we have to use Buffer(node) or Blob(browser)
+ */
+function createBlob(data, type) {
+  var blob = new Blob([data], {
+    type
+  });
+  return blob;
+}
+async function createBlobFromBase64(base64String, type) {
+  var base64Response = await fetch("data:" + type + ";base64," + base64String);
+  var blob = await base64Response.blob();
+  return blob;
+}
+function blobToString(blob) {
+  /**
+   * in the electron-renderer we have a typed array instead of a blob
+   * so we have to transform it.
+   * @link https://github.com/pubkey/rxdb/issues/1371
+   */
+  var blobType = Object.prototype.toString.call(blob);
+  if (blobType === '[object Uint8Array]') {
+    blob = new Blob([blob]);
+  }
+  if (typeof blob === 'string') {
+    return Promise.resolve(blob);
+  }
+  return blob.text();
+}
+async function blobToBase64String(blob) {
+  if (typeof blob === 'string') {
+    return blob;
+  }
+
+  /**
+   * in the electron-renderer we have a typed array instead of a blob
+   * so we have to transform it.
+   * @link https://github.com/pubkey/rxdb/issues/1371
+   */
+  var blobType = Object.prototype.toString.call(blob);
+  if (blobType === '[object Uint8Array]') {
+    blob = new Blob([blob]);
+  }
+  var arrayBuffer = await blob.arrayBuffer();
+  return (0, _utilsBase.arrayBufferToBase64)(arrayBuffer);
+}
+//# sourceMappingURL=utils-blob.js.map

package/dist/cjs/plugins/utils/utils-blob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-blob.js","names":["_utilsBase","require","createBlob","data","type","blob","Blob","createBlobFromBase64","base64String","base64Response","fetch","blobToString","blobType","Object","prototype","toString","call","Promise","resolve","text","blobToBase64String","arrayBuffer","arrayBufferToBase64"],"sources":["../../../../src/plugins/utils/utils-blob.ts"],"sourcesContent":["import { arrayBufferToBase64 } from './utils-base64.ts';\r\n\r\n/**\r\n * Since RxDB 13.0.0 we only use Blob instead of falling back to Buffer,\r\n * because Node.js >18 supports Blobs anyway.\r\n */\r\n/**\r\n * depending if we are on node or browser,\r\n * we have to use Buffer(node) or Blob(browser)\r\n */\r\nexport function createBlob(\r\n    data: string,\r\n    type: string\r\n): Blob {\r\n    const blob = new Blob([data], {\r\n        type\r\n    });\r\n    return blob;\r\n}\r\n\r\nexport async function createBlobFromBase64(\r\n    base64String: string,\r\n    type: string\r\n): Promise<Blob> {\r\n    const base64Response = await fetch(`data:${type};base64,${base64String}`);\r\n    const blob = await base64Response.blob();\r\n    return blob;\r\n}\r\n\r\nexport function blobToString(blob: Blob | string): Promise<string> {\r\n    /**\r\n     * in the electron-renderer we have a typed array instead of a blob\r\n     * so we have to transform it.\r\n     * @link https://github.com/pubkey/rxdb/issues/1371\r\n     */\r\n    const blobType = Object.prototype.toString.call(blob);\r\n    if (blobType === '[object Uint8Array]') {\r\n        blob = new Blob([blob]);\r\n    }\r\n    if (typeof blob === 'string') {\r\n        return Promise.resolve(blob);\r\n    }\r\n\r\n    return blob.text();\r\n}\r\n\r\nexport async function blobToBase64String(blob: Blob | string): Promise<string> {\r\n    if (typeof blob === 'string') {\r\n        return blob;\r\n    }\r\n\r\n    /**\r\n     * in the electron-renderer we have a typed array instead of a blob\r\n     * so we have to transform it.\r\n     * @link https://github.com/pubkey/rxdb/issues/1371\r\n     */\r\n    const blobType = Object.prototype.toString.call(blob);\r\n    if (blobType === '[object Uint8Array]') {\r\n        blob = new Blob([blob]);\r\n    }\r\n\r\n    const arrayBuffer = await blob.arrayBuffer();\r\n    return arrayBufferToBase64(arrayBuffer);\r\n}\r\n\r\n"],"mappings":";;;;;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,UAAUA,CACtBC,IAAY,EACZC,IAAY,EACR;EACJ,IAAMC,IAAI,GAAG,IAAIC,IAAI,CAAC,CAACH,IAAI,CAAC,EAAE;IAC1BC;EACJ,CAAC,CAAC;EACF,OAAOC,IAAI;AACf;AAEO,eAAeE,oBAAoBA,CACtCC,YAAoB,EACpBJ,IAAY,EACC;EACb,IAAMK,cAAc,GAAG,MAAMC,KAAK,WAASN,IAAI,gBAAWI,YAAc,CAAC;EACzE,IAAMH,IAAI,GAAG,MAAMI,cAAc,CAACJ,IAAI,CAAC,CAAC;EACxC,OAAOA,IAAI;AACf;AAEO,SAASM,YAAYA,CAACN,IAAmB,EAAmB;EAC/D;AACJ;AACA;AACA;AACA;EACI,IAAMO,QAAQ,GAAGC,MAAM,CAACC,SAAS,CAACC,QAAQ,CAACC,IAAI,CAACX,IAAI,CAAC;EACrD,IAAIO,QAAQ,KAAK,qBAAqB,EAAE;IACpCP,IAAI,GAAG,IAAIC,IAAI,CAAC,CAACD,IAAI,CAAC,CAAC;EAC3B;EACA,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IAC1B,OAAOY,OAAO,CAACC,OAAO,CAACb,IAAI,CAAC;EAChC;EAEA,OAAOA,IAAI,CAACc,IAAI,CAAC,CAAC;AACtB;AAEO,eAAeC,kBAAkBA,CAACf,IAAmB,EAAmB;EAC3E,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IAC1B,OAAOA,IAAI;EACf;;EAEA;AACJ;AACA;AACA;AACA;EACI,IAAMO,QAAQ,GAAGC,MAAM,CAACC,SAAS,CAACC,QAAQ,CAACC,IAAI,CAACX,IAAI,CAAC;EACrD,IAAIO,QAAQ,KAAK,qBAAqB,EAAE;IACpCP,IAAI,GAAG,IAAIC,IAAI,CAAC,CAACD,IAAI,CAAC,CAAC;EAC3B;EAEA,IAAMgB,WAAW,GAAG,MAAMhB,IAAI,CAACgB,WAAW,CAAC,CAAC;EAC5C,OAAO,IAAAC,8BAAmB,EAACD,WAAW,CAAC;AAC3C","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-document.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RX_META_LWT_MINIMUM = void 0;
+exports.areRxDocumentArraysEqual = areRxDocumentArraysEqual;
+exports.getDefaultRevision = getDefaultRevision;
+exports.getDefaultRxDocumentMeta = getDefaultRxDocumentMeta;
+exports.getSortDocumentsByLastWriteTimeComparator = getSortDocumentsByLastWriteTimeComparator;
+exports.sortDocumentsByLastWriteTime = sortDocumentsByLastWriteTime;
+exports.stripMetaDataFromDocument = stripMetaDataFromDocument;
+exports.toWithDeleted = toWithDeleted;
+var _utilsObject = require("./utils-object.js");
+/**
+ * We use 1 as minimum so that the value is never falsy.
+ * This const is used in several places because querying
+ * with a value lower than the minimum could give false results.
+ */
+var RX_META_LWT_MINIMUM = exports.RX_META_LWT_MINIMUM = 1;
+function getDefaultRxDocumentMeta() {
+  return {
+    /**
+     * Set this to 1 to not waste performance
+     * while calling new Date()..
+     * The storage wrappers will anyway update
+     * the lastWrite time while calling transformDocumentDataFromRxDBToRxStorage()
+     */
+    lwt: RX_META_LWT_MINIMUM
+  };
+}
+
+/**
+ * Returns a revision that is not valid.
+ * Use this to have correct typings
+ * while the storage wrapper anyway will overwrite the revision.
+ */
+function getDefaultRevision() {
+  /**
+   * Use a non-valid revision format,
+   * to ensure that the RxStorage will throw
+   * when the revision is not replaced downstream.
+   */
+  return '';
+}
+function stripMetaDataFromDocument(docData) {
+  return Object.assign({}, docData, {
+    _meta: undefined,
+    _deleted: undefined,
+    _rev: undefined
+  });
+}
+
+/**
+ * Faster way to check the equality of document lists
+ * compared to doing a deep-equal.
+ * Here we only check the ids and revisions.
+ */
+function areRxDocumentArraysEqual(primaryPath, ar1, ar2) {
+  if (ar1.length !== ar2.length) {
+    return false;
+  }
+  var i = 0;
+  var len = ar1.length;
+  while (i < len) {
+    var row1 = ar1[i];
+    var row2 = ar2[i];
+    i++;
+    if (row1[primaryPath] !== row2[primaryPath] || row1._rev !== row2._rev || row1._meta.lwt !== row2._meta.lwt) {
+      return false;
+    }
+  }
+  return true;
+}
+function getSortDocumentsByLastWriteTimeComparator(primaryPath) {
+  return (a, b) => {
+    if (a._meta.lwt === b._meta.lwt) {
+      if (b[primaryPath] < a[primaryPath]) {
+        return 1;
+      } else {
+        return -1;
+      }
+    } else {
+      return a._meta.lwt - b._meta.lwt;
+    }
+  };
+}
+function sortDocumentsByLastWriteTime(primaryPath, docs) {
+  return docs.sort(getSortDocumentsByLastWriteTimeComparator(primaryPath));
+}
+function toWithDeleted(docData) {
+  docData = (0, _utilsObject.flatClone)(docData);
+  docData._deleted = !!docData._deleted;
+  return Object.assign(docData, {
+    _attachments: undefined,
+    _meta: undefined,
+    _rev: undefined
+  });
+}
+//# sourceMappingURL=utils-document.js.map

package/dist/cjs/plugins/utils/utils-document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-document.js","names":["_utilsObject","require","RX_META_LWT_MINIMUM","exports","getDefaultRxDocumentMeta","lwt","getDefaultRevision","stripMetaDataFromDocument","docData","Object","assign","_meta","undefined","_deleted","_rev","areRxDocumentArraysEqual","primaryPath","ar1","ar2","length","i","len","row1","row2","getSortDocumentsByLastWriteTimeComparator","a","b","sortDocumentsByLastWriteTime","docs","sort","toWithDeleted","flatClone","_attachments"],"sources":["../../../../src/plugins/utils/utils-document.ts"],"sourcesContent":["import type {\r\n    DeepReadonly,\r\n    RxDocumentData,\r\n    RxDocumentMeta,\r\n    StringKeys,\r\n    WithDeleted,\r\n    WithDeletedAndAttachments\r\n} from '../../types/index.d.ts';\r\nimport { flatClone } from './utils-object.ts';\r\n/**\r\n * We use 1 as minimum so that the value is never falsy.\r\n * This const is used in several places because querying\r\n * with a value lower than the minimum could give false results.\r\n */\r\nexport const RX_META_LWT_MINIMUM = 1;\r\n\r\nexport function getDefaultRxDocumentMeta(): RxDocumentMeta {\r\n    return {\r\n        /**\r\n         * Set this to 1 to not waste performance\r\n         * while calling new Date()..\r\n         * The storage wrappers will anyway update\r\n         * the lastWrite time while calling transformDocumentDataFromRxDBToRxStorage()\r\n         */\r\n        lwt: RX_META_LWT_MINIMUM\r\n    };\r\n}\r\n\r\n/**\r\n * Returns a revision that is not valid.\r\n * Use this to have correct typings\r\n * while the storage wrapper anyway will overwrite the revision.\r\n */\r\nexport function getDefaultRevision(): string {\r\n    /**\r\n     * Use a non-valid revision format,\r\n     * to ensure that the RxStorage will throw\r\n     * when the revision is not replaced downstream.\r\n     */\r\n    return '';\r\n}\r\n\r\n\r\nexport function stripMetaDataFromDocument<RxDocType>(docData: RxDocumentData<RxDocType>): RxDocType {\r\n    return Object.assign({}, docData, {\r\n        _meta: undefined,\r\n        _deleted: undefined,\r\n        _rev: undefined\r\n    });\r\n}\r\n\r\n\r\n/**\r\n * Faster way to check the equality of document lists\r\n * compared to doing a deep-equal.\r\n * Here we only check the ids and revisions.\r\n */\r\nexport function areRxDocumentArraysEqual<RxDocType>(\r\n    primaryPath: StringKeys<RxDocumentData<RxDocType>>,\r\n    ar1: RxDocumentData<RxDocType>[],\r\n    ar2: RxDocumentData<RxDocType>[]\r\n): boolean {\r\n    if (ar1.length !== ar2.length) {\r\n        return false;\r\n    }\r\n    let i = 0;\r\n    const len = ar1.length;\r\n    while (i < len) {\r\n        const row1 = ar1[i];\r\n        const row2 = ar2[i];\r\n        i++;\r\n\r\n        if (\r\n            row1[primaryPath] !== row2[primaryPath] ||\r\n            row1._rev !== row2._rev ||\r\n            row1._meta.lwt !== row2._meta.lwt\r\n        ) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\n\r\n\r\n\r\nexport function getSortDocumentsByLastWriteTimeComparator<RxDocType>(primaryPath: string) {\r\n    return (a: RxDocumentData<RxDocType>, b: RxDocumentData<RxDocType>) => {\r\n        if (a._meta.lwt === b._meta.lwt) {\r\n            if ((b as any)[primaryPath] < (a as any)[primaryPath]) {\r\n                return 1;\r\n            } else {\r\n                return -1;\r\n            }\r\n        } else {\r\n            return a._meta.lwt - b._meta.lwt;\r\n        }\r\n    };\r\n}\r\nexport function sortDocumentsByLastWriteTime<RxDocType>(\r\n    primaryPath: string,\r\n    docs: RxDocumentData<RxDocType>[]\r\n): RxDocumentData<RxDocType>[] {\r\n    return docs.sort(getSortDocumentsByLastWriteTimeComparator(primaryPath));\r\n}\r\n\r\ntype AnyDocFormat<RxDocType> = RxDocType | WithDeleted<RxDocType> | RxDocumentData<RxDocType> | WithDeletedAndAttachments<RxDocType>;\r\nexport function toWithDeleted<RxDocType>(\r\n    docData: AnyDocFormat<RxDocType> | DeepReadonly<AnyDocFormat<RxDocType>>\r\n): WithDeleted<RxDocType> {\r\n    docData = flatClone(docData);\r\n    (docData as any)._deleted = !!(docData as any)._deleted;\r\n    return Object.assign(docData as any, {\r\n        _attachments: undefined,\r\n        _meta: undefined,\r\n        _rev: undefined\r\n    }) as any;\r\n}\r\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAAA,YAAA,GAAAC,OAAA;AACA;AACA;AACA;AACA;AACA;AACO,IAAMC,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,GAAG,CAAC;AAE7B,SAASE,wBAAwBA,CAAA,EAAmB;EACvD,OAAO;IACH;AACR;AACA;AACA;AACA;AACA;IACQC,GAAG,EAAEH;EACT,CAAC;AACL;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASI,kBAAkBA,CAAA,EAAW;EACzC;AACJ;AACA;AACA;AACA;EACI,OAAO,EAAE;AACb;AAGO,SAASC,yBAAyBA,CAAYC,OAAkC,EAAa;EAChG,OAAOC,MAAM,CAACC,MAAM,CAAC,CAAC,CAAC,EAAEF,OAAO,EAAE;IAC9BG,KAAK,EAAEC,SAAS;IAChBC,QAAQ,EAAED,SAAS;IACnBE,IAAI,EAAEF;EACV,CAAC,CAAC;AACN;;AAGA;AACA;AACA;AACA;AACA;AACO,SAASG,wBAAwBA,CACpCC,WAAkD,EAClDC,GAAgC,EAChCC,GAAgC,EACzB;EACP,IAAID,GAAG,CAACE,MAAM,KAAKD,GAAG,CAACC,MAAM,EAAE;IAC3B,OAAO,KAAK;EAChB;EACA,IAAIC,CAAC,GAAG,CAAC;EACT,IAAMC,GAAG,GAAGJ,GAAG,CAACE,MAAM;EACtB,OAAOC,CAAC,GAAGC,GAAG,EAAE;IACZ,IAAMC,IAAI,GAAGL,GAAG,CAACG,CAAC,CAAC;IACnB,IAAMG,IAAI,GAAGL,GAAG,CAACE,CAAC,CAAC;IACnBA,CAAC,EAAE;IAEH,IACIE,IAAI,CAACN,WAAW,CAAC,KAAKO,IAAI,CAACP,WAAW,CAAC,IACvCM,IAAI,CAACR,IAAI,KAAKS,IAAI,CAACT,IAAI,IACvBQ,IAAI,CAACX,KAAK,CAACN,GAAG,KAAKkB,IAAI,CAACZ,KAAK,CAACN,GAAG,EACnC;MACE,OAAO,KAAK;IAChB;EACJ;EACA,OAAO,IAAI;AACf;AAIO,SAASmB,yCAAyCA,CAAYR,WAAmB,EAAE;EACtF,OAAO,CAACS,CAA4B,EAAEC,CAA4B,KAAK;IACnE,IAAID,CAAC,CAACd,KAAK,CAACN,GAAG,KAAKqB,CAAC,CAACf,KAAK,CAACN,GAAG,EAAE;MAC7B,IAAKqB,CAAC,CAASV,WAAW,CAAC,GAAIS,CAAC,CAAST,WAAW,CAAC,EAAE;QACnD,OAAO,CAAC;MACZ,CAAC,MAAM;QACH,OAAO,CAAC,CAAC;MACb;IACJ,CAAC,MAAM;MACH,OAAOS,CAAC,CAACd,KAAK,CAACN,GAAG,GAAGqB,CAAC,CAACf,KAAK,CAACN,GAAG;IACpC;EACJ,CAAC;AACL;AACO,SAASsB,4BAA4BA,CACxCX,WAAmB,EACnBY,IAAiC,EACN;EAC3B,OAAOA,IAAI,CAACC,IAAI,CAACL,yCAAyC,CAACR,WAAW,CAAC,CAAC;AAC5E;AAGO,SAASc,aAAaA,CACzBtB,OAAwE,EAClD;EACtBA,OAAO,GAAG,IAAAuB,sBAAS,EAACvB,OAAO,CAAC;EAC3BA,OAAO,CAASK,QAAQ,GAAG,CAAC,CAAEL,OAAO,CAASK,QAAQ;EACvD,OAAOJ,MAAM,CAACC,MAAM,CAACF,OAAO,EAAS;IACjCwB,YAAY,EAAEpB,SAAS;IACvBD,KAAK,EAAEC,SAAS;IAChBE,IAAI,EAAEF;EACV,CAAC,CAAC;AACN","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-error.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorToPlainJson = errorToPlainJson;
+exports.pluginMissing = pluginMissing;
+var _utilsString = require("./utils-string.js");
+/**
+ * Returns an error that indicates that a plugin is missing
+ * We do not throw a RxError because this should not be handled
+ * programmatically but by using the correct import
+ */
+function pluginMissing(pluginKey) {
+  var keyParts = pluginKey.split('-');
+  var pluginName = 'RxDB';
+  keyParts.forEach(part => {
+    pluginName += (0, _utilsString.ucfirst)(part);
+  });
+  pluginName += 'Plugin';
+  return new Error("You are using a function which must be overwritten by a plugin.\n        You should either prevent the usage of this function or add the plugin via:\n            import { " + pluginName + " } from 'rxdb/plugins/" + pluginKey + "';\n            addRxPlugin(" + pluginName + ");\n        ");
+}
+function errorToPlainJson(err) {
+  var ret = {
+    name: err.name,
+    message: err.message,
+    rxdb: err.rxdb,
+    parameters: err.parameters,
+    extensions: err.extensions,
+    code: err.code,
+    url: err.url,
+    /**
+     * stack must be last to make it easier to read the json in a console.
+     * Also we ensure that each linebreak is spaced so that the chrome devtools
+     * shows urls to the source code that can be clicked to inspect
+     * the correct place in the code.
+     */
+    stack: !err.stack ? undefined : err.stack.replace(/\n/g, ' \n ')
+  };
+  return ret;
+}
+//# sourceMappingURL=utils-error.js.map

package/dist/cjs/plugins/utils/utils-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-error.js","names":["_utilsString","require","pluginMissing","pluginKey","keyParts","split","pluginName","forEach","part","ucfirst","Error","errorToPlainJson","err","ret","name","message","rxdb","parameters","extensions","code","url","stack","undefined","replace"],"sources":["../../../../src/plugins/utils/utils-error.ts"],"sourcesContent":["import type {\r\n    PlainJsonError,\r\n    RxError,\r\n    RxTypeError\r\n} from '../../types/index.d.ts';\r\nimport { ucfirst } from './utils-string.ts';\r\n\r\n\r\n\r\n/**\r\n * Returns an error that indicates that a plugin is missing\r\n * We do not throw a RxError because this should not be handled\r\n * programmatically but by using the correct import\r\n */\r\nexport function pluginMissing(\r\n    pluginKey: string\r\n): Error {\r\n    const keyParts = pluginKey.split('-');\r\n    let pluginName = 'RxDB';\r\n    keyParts.forEach(part => {\r\n        pluginName += ucfirst(part);\r\n    });\r\n    pluginName += 'Plugin';\r\n    return new Error(\r\n        `You are using a function which must be overwritten by a plugin.\r\n        You should either prevent the usage of this function or add the plugin via:\r\n            import { ${pluginName} } from 'rxdb/plugins/${pluginKey}';\r\n            addRxPlugin(${pluginName});\r\n        `\r\n    );\r\n}\r\n\r\n\r\n\r\nexport function errorToPlainJson(err: Error | TypeError | RxError | RxTypeError): PlainJsonError {\r\n    const ret: PlainJsonError = {\r\n        name: err.name,\r\n        message: err.message,\r\n        rxdb: (err as any).rxdb,\r\n        parameters: (err as RxError).parameters,\r\n        extensions: (err as any).extensions,\r\n        code: (err as RxError).code,\r\n        url: (err as RxError).url,\r\n        /**\r\n         * stack must be last to make it easier to read the json in a console.\r\n         * Also we ensure that each linebreak is spaced so that the chrome devtools\r\n         * shows urls to the source code that can be clicked to inspect\r\n         * the correct place in the code.\r\n         */\r\n        stack: !err.stack ? undefined : err.stack.replace(/\\n/g, ' \\n ')\r\n    };\r\n    return ret;\r\n}\r\n"],"mappings":";;;;;;;AAKA,IAAAA,YAAA,GAAAC,OAAA;AAIA;AACA;AACA;AACA;AACA;AACO,SAASC,aAAaA,CACzBC,SAAiB,EACZ;EACL,IAAMC,QAAQ,GAAGD,SAAS,CAACE,KAAK,CAAC,GAAG,CAAC;EACrC,IAAIC,UAAU,GAAG,MAAM;EACvBF,QAAQ,CAACG,OAAO,CAACC,IAAI,IAAI;IACrBF,UAAU,IAAI,IAAAG,oBAAO,EAACD,IAAI,CAAC;EAC/B,CAAC,CAAC;EACFF,UAAU,IAAI,QAAQ;EACtB,OAAO,IAAII,KAAK,iLAGGJ,UAAU,8BAAyBH,SAAS,oCACzCG,UAAU,iBAEhC,CAAC;AACL;AAIO,SAASK,gBAAgBA,CAACC,GAA8C,EAAkB;EAC7F,IAAMC,GAAmB,GAAG;IACxBC,IAAI,EAAEF,GAAG,CAACE,IAAI;IACdC,OAAO,EAAEH,GAAG,CAACG,OAAO;IACpBC,IAAI,EAAGJ,GAAG,CAASI,IAAI;IACvBC,UAAU,EAAGL,GAAG,CAAaK,UAAU;IACvCC,UAAU,EAAGN,GAAG,CAASM,UAAU;IACnCC,IAAI,EAAGP,GAAG,CAAaO,IAAI;IAC3BC,GAAG,EAAGR,GAAG,CAAaQ,GAAG;IACzB;AACR;AACA;AACA;AACA;AACA;IACQC,KAAK,EAAE,CAACT,GAAG,CAACS,KAAK,GAAGC,SAAS,GAAGV,GAAG,CAACS,KAAK,CAACE,OAAO,CAAC,KAAK,EAAE,MAAM;EACnE,CAAC;EACD,OAAOV,GAAG;AACd","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-global.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RXDB_UTILS_GLOBAL = void 0;
+/**
+ * Can be used by some plugins to have a "global" object that
+ * can be imported and mutated at will.
+ */
+var RXDB_UTILS_GLOBAL = exports.RXDB_UTILS_GLOBAL = {};
+//# sourceMappingURL=utils-global.js.map

package/dist/cjs/plugins/utils/utils-global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-global.js","names":["RXDB_UTILS_GLOBAL","exports"],"sources":["../../../../src/plugins/utils/utils-global.ts"],"sourcesContent":["/**\r\n * Can be used by some plugins to have a \"global\" object that\r\n * can be imported and mutated at will.\r\n */\r\nexport const RXDB_UTILS_GLOBAL: any = {};\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACO,IAAMA,iBAAsB,GAAAC,OAAA,CAAAD,iBAAA,GAAG,CAAC,CAAC","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-hash.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultHashSha256 = void 0;
+exports.hashStringToNumber = hashStringToNumber;
+exports.nativeSha256 = nativeSha256;
+var _rxError = require("../../rx-error.js");
+/**
+ * Cache this here so we do not have to run the try-catch
+ * each time for better performance.
+ * If your JavaScript runtime does not support crypto.subtle.digest,
+ * provide your own hash function when calling createRxDatabase().
+ */
+var hashFn;
+function getHashFn() {
+  if (hashFn) {
+    return hashFn;
+  }
+  if (typeof crypto === 'undefined' || typeof crypto.subtle === 'undefined' || typeof crypto.subtle.digest !== 'function') {
+    throw (0, _rxError.newRxError)('UT8', {
+      args: {
+        typeof_crypto: typeof crypto,
+        typeof_crypto_subtle: typeof crypto?.subtle,
+        typeof_crypto_subtle_digest: typeof crypto?.subtle?.digest
+      }
+    });
+  }
+  hashFn = crypto.subtle.digest.bind(crypto.subtle);
+  return hashFn;
+}
+async function nativeSha256(input) {
+  var data;
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    data = await input.arrayBuffer();
+  } else if (typeof input === 'string') {
+    data = new TextEncoder().encode(input);
+  } else {
+    data = input;
+  }
+  var hashBuffer = await getHashFn()('SHA-256', data);
+  /**
+   * @link https://jameshfisher.com/2017/10/30/web-cryptography-api-hello-world/
+   */
+  var hash = Array.prototype.map.call(new Uint8Array(hashBuffer), x => ('00' + x.toString(16)).slice(-2)).join('');
+  return hash;
+}
+var defaultHashSha256 = exports.defaultHashSha256 = nativeSha256;
+function hashStringToNumber(str) {
+  var nr = 0;
+  var len = str.length;
+  for (var i = 0; i < len; i++) {
+    nr = nr + str.charCodeAt(i);
+    nr |= 0; // Convert to 32bit integer, improves performance
+  }
+  return nr;
+}
+//# sourceMappingURL=utils-hash.js.map

package/dist/cjs/plugins/utils/utils-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-hash.js","names":["_rxError","require","hashFn","getHashFn","crypto","subtle","digest","newRxError","args","typeof_crypto","typeof_crypto_subtle","typeof_crypto_subtle_digest","bind","nativeSha256","input","data","Blob","arrayBuffer","TextEncoder","encode","hashBuffer","hash","Array","prototype","map","call","Uint8Array","x","toString","slice","join","defaultHashSha256","exports","hashStringToNumber","str","nr","len","length","i","charCodeAt"],"sources":["../../../../src/plugins/utils/utils-hash.ts"],"sourcesContent":["import { newRxError } from '../../rx-error.ts';\r\nimport type { HashFunction } from '../../types/index.d.ts';\r\n\r\n/**\r\n * Cache this here so we do not have to run the try-catch\r\n * each time for better performance.\r\n * If your JavaScript runtime does not support crypto.subtle.digest,\r\n * provide your own hash function when calling createRxDatabase().\r\n */\r\nlet hashFn: typeof crypto.subtle.digest;\r\nfunction getHashFn() {\r\n    if (hashFn) {\r\n        return hashFn;\r\n    }\r\n    if (\r\n        typeof crypto === 'undefined' ||\r\n        typeof crypto.subtle === 'undefined' ||\r\n        typeof crypto.subtle.digest !== 'function'\r\n    ) {\r\n        throw newRxError('UT8', {\r\n            args: {\r\n                typeof_crypto: typeof crypto,\r\n                typeof_crypto_subtle: typeof crypto?.subtle,\r\n                typeof_crypto_subtle_digest: typeof crypto?.subtle?.digest\r\n            }\r\n        });\r\n    }\r\n    hashFn = crypto.subtle.digest.bind(crypto.subtle);\r\n    return hashFn;\r\n}\r\n\r\nexport async function nativeSha256(input: string | ArrayBuffer | Blob) {\r\n    let data: BufferSource;\r\n    if (typeof Blob !== \"undefined\" && input instanceof Blob) {\r\n        data = await input.arrayBuffer();\r\n    } else if (typeof input === 'string') {\r\n        data = new TextEncoder().encode(input);\r\n    } else {\r\n        data = input as ArrayBuffer;\r\n    }\r\n    const hashBuffer = await getHashFn()('SHA-256', data);\r\n    /**\r\n     * @link https://jameshfisher.com/2017/10/30/web-cryptography-api-hello-world/\r\n     */\r\n    const hash = Array.prototype.map.call(\r\n        new Uint8Array(hashBuffer),\r\n        x => (('00' + x.toString(16)).slice(-2))\r\n    ).join('');\r\n    return hash;\r\n}\r\n\r\nexport const defaultHashSha256: HashFunction = nativeSha256;\r\n\r\nexport function hashStringToNumber(str: string): number {\r\n    let nr = 0;\r\n    const len = str.length;\r\n    for (let i = 0; i < len; i++) {\r\n        nr = nr + str.charCodeAt(i);\r\n        nr |= 0; // Convert to 32bit integer, improves performance\r\n    }\r\n    return nr;\r\n}\r\n"],"mappings":";;;;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,IAAIC,MAAmC;AACvC,SAASC,SAASA,CAAA,EAAG;EACjB,IAAID,MAAM,EAAE;IACR,OAAOA,MAAM;EACjB;EACA,IACI,OAAOE,MAAM,KAAK,WAAW,IAC7B,OAAOA,MAAM,CAACC,MAAM,KAAK,WAAW,IACpC,OAAOD,MAAM,CAACC,MAAM,CAACC,MAAM,KAAK,UAAU,EAC5C;IACE,MAAM,IAAAC,mBAAU,EAAC,KAAK,EAAE;MACpBC,IAAI,EAAE;QACFC,aAAa,EAAE,OAAOL,MAAM;QAC5BM,oBAAoB,EAAE,OAAON,MAAM,EAAEC,MAAM;QAC3CM,2BAA2B,EAAE,OAAOP,MAAM,EAAEC,MAAM,EAAEC;MACxD;IACJ,CAAC,CAAC;EACN;EACAJ,MAAM,GAAGE,MAAM,CAACC,MAAM,CAACC,MAAM,CAACM,IAAI,CAACR,MAAM,CAACC,MAAM,CAAC;EACjD,OAAOH,MAAM;AACjB;AAEO,eAAeW,YAAYA,CAACC,KAAkC,EAAE;EACnE,IAAIC,IAAkB;EACtB,IAAI,OAAOC,IAAI,KAAK,WAAW,IAAIF,KAAK,YAAYE,IAAI,EAAE;IACtDD,IAAI,GAAG,MAAMD,KAAK,CAACG,WAAW,CAAC,CAAC;EACpC,CAAC,MAAM,IAAI,OAAOH,KAAK,KAAK,QAAQ,EAAE;IAClCC,IAAI,GAAG,IAAIG,WAAW,CAAC,CAAC,CAACC,MAAM,CAACL,KAAK,CAAC;EAC1C,CAAC,MAAM;IACHC,IAAI,GAAGD,KAAoB;EAC/B;EACA,IAAMM,UAAU,GAAG,MAAMjB,SAAS,CAAC,CAAC,CAAC,SAAS,EAAEY,IAAI,CAAC;EACrD;AACJ;AACA;EACI,IAAMM,IAAI,GAAGC,KAAK,CAACC,SAAS,CAACC,GAAG,CAACC,IAAI,CACjC,IAAIC,UAAU,CAACN,UAAU,CAAC,EAC1BO,CAAC,IAAK,CAAC,IAAI,GAAGA,CAAC,CAACC,QAAQ,CAAC,EAAE,CAAC,EAAEC,KAAK,CAAC,CAAC,CAAC,CAC1C,CAAC,CAACC,IAAI,CAAC,EAAE,CAAC;EACV,OAAOT,IAAI;AACf;AAEO,IAAMU,iBAA+B,GAAAC,OAAA,CAAAD,iBAAA,GAAGlB,YAAY;AAEpD,SAASoB,kBAAkBA,CAACC,GAAW,EAAU;EACpD,IAAIC,EAAE,GAAG,CAAC;EACV,IAAMC,GAAG,GAAGF,GAAG,CAACG,MAAM;EACtB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,GAAG,EAAEE,CAAC,EAAE,EAAE;IAC1BH,EAAE,GAAGA,EAAE,GAAGD,GAAG,CAACK,UAAU,CAACD,CAAC,CAAC;IAC3BH,EAAE,IAAI,CAAC,CAAC,CAAC;EACb;EACA,OAAOA,EAAE;AACb","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-map.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFromMapOrCreate = getFromMapOrCreate;
+exports.getFromMapOrThrow = getFromMapOrThrow;
+function getFromMapOrThrow(map, key) {
+  var val = map.get(key);
+  if (typeof val === 'undefined') {
+    throw new Error('missing value from map ' + key);
+  }
+  return val;
+}
+function getFromMapOrCreate(map, index, creator, ifWasThere) {
+  var value = map.get(index);
+  if (typeof value === 'undefined') {
+    value = creator();
+    map.set(index, value);
+  } else if (ifWasThere) {
+    ifWasThere(value);
+  }
+  return value;
+}
+//# sourceMappingURL=utils-map.js.map

package/dist/cjs/plugins/utils/utils-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-map.js","names":["getFromMapOrThrow","map","key","val","get","Error","getFromMapOrCreate","index","creator","ifWasThere","value","set"],"sources":["../../../../src/plugins/utils/utils-map.ts"],"sourcesContent":["export function getFromMapOrThrow<K, V>(map: Map<K, V> | WeakMap<any, V>, key: K): V {\r\n    const val = map.get(key);\r\n    if (typeof val === 'undefined') {\r\n        throw new Error('missing value from map ' + key);\r\n    }\r\n    return val;\r\n}\r\n\r\nexport function getFromMapOrCreate<MapIndex, MapValue>(\r\n    map: Map<MapIndex, MapValue> | WeakMap<any, MapValue>,\r\n    index: MapIndex,\r\n    creator: () => MapValue,\r\n    ifWasThere?: (value: MapValue) => void\r\n): MapValue {\r\n    let value = map.get(index);\r\n    if (typeof value === 'undefined') {\r\n        value = creator();\r\n        map.set(index, value);\r\n    } else if (ifWasThere) {\r\n        ifWasThere(value);\r\n    }\r\n    return value;\r\n}\r\n"],"mappings":";;;;;;;AAAO,SAASA,iBAAiBA,CAAOC,GAAgC,EAAEC,GAAM,EAAK;EACjF,IAAMC,GAAG,GAAGF,GAAG,CAACG,GAAG,CAACF,GAAG,CAAC;EACxB,IAAI,OAAOC,GAAG,KAAK,WAAW,EAAE;IAC5B,MAAM,IAAIE,KAAK,CAAC,yBAAyB,GAAGH,GAAG,CAAC;EACpD;EACA,OAAOC,GAAG;AACd;AAEO,SAASG,kBAAkBA,CAC9BL,GAAqD,EACrDM,KAAe,EACfC,OAAuB,EACvBC,UAAsC,EAC9B;EACR,IAAIC,KAAK,GAAGT,GAAG,CAACG,GAAG,CAACG,KAAK,CAAC;EAC1B,IAAI,OAAOG,KAAK,KAAK,WAAW,EAAE;IAC9BA,KAAK,GAAGF,OAAO,CAAC,CAAC;IACjBP,GAAG,CAACU,GAAG,CAACJ,KAAK,EAAEG,KAAK,CAAC;EACzB,CAAC,MAAM,IAAID,UAAU,EAAE;IACnBA,UAAU,CAACC,KAAK,CAAC;EACrB;EACA,OAAOA,KAAK;AAChB","ignoreList":[]}

package/dist/cjs/plugins/utils/utils-number.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomNumber = randomNumber;
+/**
+ * returns a random number
+ * @param  {number} [min=0] inclusive
+ * @param  {number} [max=1000] inclusive
+ * @return {number}
+ */
+function randomNumber(min = 0, max = 1000) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+//# sourceMappingURL=utils-number.js.map

package/dist/cjs/plugins/utils/utils-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-number.js","names":["randomNumber","min","max","Math","floor","random"],"sources":["../../../../src/plugins/utils/utils-number.ts"],"sourcesContent":["/**\r\n * returns a random number\r\n * @param  {number} [min=0] inclusive\r\n * @param  {number} [max=1000] inclusive\r\n * @return {number}\r\n */\r\nexport function randomNumber(min = 0, max = 1000): number {\r\n    return Math.floor(Math.random() * (max - min + 1)) + min;\r\n}\r\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,YAAYA,CAACC,GAAG,GAAG,CAAC,EAAEC,GAAG,GAAG,IAAI,EAAU;EACtD,OAAOC,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,MAAM,CAAC,CAAC,IAAIH,GAAG,GAAGD,GAAG,GAAG,CAAC,CAAC,CAAC,GAAGA,GAAG;AAC5D","ignoreList":[]}