@hocuspocus/common 2.0.1 → 2.0.3

package/dist/hocuspocus-common.cjs

@@ -31,20 +31,47 @@ const fromCamelCaseRegex = /([A-Z])/g;
  */
 const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, match => `${separator}${toLowerCase(match)}`));
 
-/* istanbul ignore next */
-/** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Polyfill = str => {
+  const encodedString = unescape(encodeURIComponent(str));
+  const len = encodedString.length;
+  const buf = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    buf[i] = /** @type {number} */ (encodedString.codePointAt(i));
+  }
+  return buf
+};
 
-/* istanbul ignore next */
+/* c8 ignore next */
+const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'undefined' ? new TextEncoder() : null);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
+
+/**
+ * @param {string} str
+ * @return {Uint8Array}
+ */
+/* c8 ignore next */
+const encodeUtf8 = utf8TextEncoder ? _encodeUtf8Native : _encodeUtf8Polyfill;
+
+/* c8 ignore next */
 let utf8TextDecoder = typeof TextDecoder === 'undefined' ? null : new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 
-/* istanbul ignore next */
+/* c8 ignore start */
 if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
   // Safari doesn't handle BOM correctly.
   // This fixes a bug in Safari 13.0.5 where it produces a BOM the first time it is called.
   // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the first call and
   // utf8TextDecoder.decode(new Uint8Array()).length === 1 on the second call
   // Another issue is that from then on no BOM chars are recognized anymore
-  /* istanbul ignore next */
+  /* c8 ignore next */
   utf8TextDecoder = null;
 }
 
@@ -62,7 +89,7 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
  *
  * @function
  */
-const create = () => new Map();
+const create$1 = () => new Map();
 
 /**
  * Often used conditions.
@@ -75,10 +102,10 @@ const create = () => new Map();
  * @param {T|null|undefined} v
  * @return {T|null}
  */
-/* istanbul ignore next */
+/* c8 ignore next */
 const undefinedToNull = v => v === undefined ? null : v;
 
-/* global localStorage, addEventListener */
+/* eslint-env browser */
 
 /**
  * Isomorphic variable storage.
@@ -88,7 +115,7 @@ const undefinedToNull = v => v === undefined ? null : v;
  * @module storage
  */
 
-/* istanbul ignore next */
+/* c8 ignore start */
 class VarStoragePolyfill {
   constructor () {
     this.map = new Map();
@@ -109,54 +136,74 @@ class VarStoragePolyfill {
     return this.map.get(key)
   }
 }
+/* c8 ignore stop */
 
-/* istanbul ignore next */
 /**
  * @type {any}
  */
 let _localStorage = new VarStoragePolyfill();
 let usePolyfill = true;
 
+/* c8 ignore start */
 try {
   // if the same-origin rule is violated, accessing localStorage might thrown an error
-  /* istanbul ignore next */
   if (typeof localStorage !== 'undefined') {
     _localStorage = localStorage;
     usePolyfill = false;
   }
 } catch (e) { }
+/* c8 ignore stop */
 
-/* istanbul ignore next */
 /**
  * This is basically localStorage in browser, or a polyfill in nodejs
  */
+/* c8 ignore next */
 const varStorage = _localStorage;
 
+/**
+ * Common functions and function call helpers.
+ *
+ * @module function
+ */
+
+/**
+ * @template V
+ * @template {V} OPTS
+ *
+ * @param {V} value
+ * @param {Array<OPTS>} options
+ */
+// @ts-ignore
+const isOneOf = (value, options) => options.includes(value);
+/* c8 ignore stop */
+
 /**
  * Isomorphic module to work access the environment (query params, env variables).
  *
  * @module map
  */
 
-/* istanbul ignore next */
+/* c8 ignore next */
 // @ts-ignore
-const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name);
-/* istanbul ignore next */
-typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false;
+const isNode = typeof process !== 'undefined' && process.release &&
+  /node|io\.js/.test(process.release.name);
+/* c8 ignore next 3 */
+typeof navigator !== 'undefined'
+  ? /Mac/.test(navigator.platform)
+  : false;
 
 /**
  * @type {Map<string,string>}
  */
 let params;
 
-/* istanbul ignore next */
+/* c8 ignore start */
 const computeParams = () => {
   if (params === undefined) {
     if (isNode) {
-      params = create();
+      params = create$1();
       const pargs = process.argv;
       let currParamName = null;
-      /* istanbul ignore next */
       for (let i = 0; i < pargs.length; i++) {
         const parg = pargs[i];
         if (parg[0] === '-') {
@@ -174,11 +221,10 @@ const computeParams = () => {
       if (currParamName !== null) {
         params.set(currParamName, '');
       }
-    // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
+      // in ReactNative for example this would not be true (unless connected to the Remote Debugger)
     } else if (typeof location === 'object') {
-      params = create()
-      // eslint-disable-next-line no-undef
-      ;(location.search || '?').slice(1).split('&').forEach(kv => {
+      params = create$1(); // eslint-disable-next-line no-undef
+      (location.search || '?').slice(1).split('&').forEach((kv) => {
         if (kv.length !== 0) {
           const [key, value] = kv.split('=');
           params.set(`--${fromCamelCase(key, '-')}`, value);
@@ -186,41 +232,103 @@ const computeParams = () => {
         }
       });
     } else {
-      params = create();
+      params = create$1();
     }
   }
   return params
 };
+/* c8 ignore stop */
 
 /**
  * @param {string} name
  * @return {boolean}
  */
-/* istanbul ignore next */
-const hasParam = name => computeParams().has(name);
-// export const getArgs = name => computeParams() && args
+/* c8 ignore next */
+const hasParam = (name) => computeParams().has(name);
 
 /**
  * @param {string} name
  * @return {string|null}
  */
-/* istanbul ignore next */
-const getVariable = name => isNode ? undefinedToNull(process.env[name.toUpperCase()]) : undefinedToNull(varStorage.getItem(name));
+/* c8 ignore next 4 */
+const getVariable = (name) =>
+  isNode
+    ? undefinedToNull(process.env[name.toUpperCase()])
+    : undefinedToNull(varStorage.getItem(name));
 
 /**
  * @param {string} name
  * @return {boolean}
  */
-/* istanbul ignore next */
-const hasConf = name => hasParam('--' + name) || getVariable(name) !== null;
+/* c8 ignore next 2 */
+const hasConf = (name) =>
+  hasParam('--' + name) || getVariable(name) !== null;
 
-/* istanbul ignore next */
+/* c8 ignore next */
 hasConf('production');
 
+/* c8 ignore next 2 */
+const forceColor = isNode &&
+  isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']);
+
+/* c8 ignore start */
+!hasParam('no-colors') &&
+  (!isNode || process.stdout.isTTY || forceColor) && (
+  !isNode || hasParam('color') || forceColor ||
+    getVariable('COLORTERM') !== null ||
+    (getVariable('TERM') || '').includes('color')
+);
+/* c8 ignore stop */
+
 /* eslint-env browser */
 const BIT8 = 128;
 const BITS7 = 127;
 
+/**
+ * Common Math expressions.
+ *
+ * @module math
+ */
+
+const floor = Math.floor;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The smaller element of a and b
+ */
+const min = (a, b) => a < b ? a : b;
+
+/**
+ * @function
+ * @param {number} a
+ * @param {number} b
+ * @return {number} The bigger element of a and b
+ */
+const max = (a, b) => a > b ? a : b;
+
+/**
+ * Utility helpers for working with numbers.
+ *
+ * @module number
+ */
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+
+/**
+ * Error helpers.
+ *
+ * @module error
+ */
+
+/**
+ * @param {string} s
+ * @return {Error}
+ */
+/* c8 ignore next */
+const create = s => new Error(s);
+
 /**
  * Efficient schema-less binary decoding with support for variable length encoding.
  *
@@ -232,7 +340,7 @@ const BITS7 = 127;
  *
  * ```js
  * // encoding step
- * const encoder = new encoding.createEncoder()
+ * const encoder = encoding.createEncoder()
  * encoding.writeVarUint(encoder, 256)
  * encoding.writeVarString(encoder, 'Hello world!')
  * const buf = encoding.toUint8Array(encoder)
@@ -240,7 +348,7 @@ const BITS7 = 127;
  *
  * ```js
  * // decoding step
- * const decoder = new decoding.createDecoder(buf)
+ * const decoder = decoding.createDecoder(buf)
  * decoding.readVarUint(decoder) // => 256
  * decoding.readVarString(decoder) // => 'Hello world!'
  * decoding.hasContent(decoder) // => false - all data is read
@@ -249,6 +357,38 @@ const BITS7 = 127;
  * @module decoding
  */
 
+const errorUnexpectedEndOfArray = create('Unexpected end of array');
+const errorIntegerOutOfRange = create('Integer out of Range');
+
+/**
+ * Create an Uint8Array view of the next `len` bytes and advance the position by `len`.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder The decoder instance
+ * @param {number} len The length of bytes to read
+ * @return {Uint8Array}
+ */
+const readUint8Array = (decoder, len) => {
+  const view = createUint8ArrayViewFromArrayBuffer(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  decoder.pos += len;
+  return view
+};
+
+/**
+ * Read variable length Uint8Array.
+ *
+ * Important: The Uint8Array still points to the underlying ArrayBuffer. Make sure to discard the result as soon as possible to prevent any memory leaks.
+ *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {Uint8Array}
+ */
+const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
+
 /**
  * Read one byte as unsigned integer.
  * @function
@@ -269,24 +409,28 @@ const readUint8 = decoder => decoder.arr[decoder.pos++];
  */
 const readVarUint = decoder => {
   let num = 0;
-  let len = 0;
-  while (true) {
+  let mult = 1;
+  const len = decoder.arr.length;
+  while (decoder.pos < len) {
     const r = decoder.arr[decoder.pos++];
-    num = num | ((r & BITS7) << len);
-    len += 7;
+    // num = num | ((r & binary.BITS7) << len)
+    num = num + (r & BITS7) * mult; // shift $r << (7*#iterations) and add it to num
+    mult *= 128; // next iteration, shift 7 "more" to the left
     if (r < BIT8) {
-      return num >>> 0 // return unsigned number!
+      return num
     }
-    /* istanbul ignore if */
-    if (len > 35) {
-      throw new Error('Integer out of range!')
+    /* c8 ignore start */
+    if (num > MAX_SAFE_INTEGER) {
+      throw errorIntegerOutOfRange
     }
+    /* c8 ignore stop */
   }
+  throw errorUnexpectedEndOfArray
 };
 
 /**
- * Read string of variable length
- * * varUint is used to store the length of the string
+ * We don't test this function anymore as we use native decoding/encoding by default now.
+ * Better not modify this anymore..
  *
  * Transforming utf8 to a string is pretty expensive. The code performs 10x better
  * when String.fromCodePoint is fed with all characters as arguments.
@@ -297,7 +441,8 @@ const readVarUint = decoder => {
  * @param {Decoder} decoder
  * @return {String} The read String.
  */
-const readVarString = decoder => {
+/* c8 ignore start */
+const _readVarStringPolyfill = decoder => {
   let remainingLen = readVarUint(decoder);
   if (remainingLen === 0) {
     return ''
@@ -321,6 +466,42 @@ const readVarString = decoder => {
     return decodeURIComponent(escape(encodedString))
   }
 };
+/* c8 ignore stop */
+
+/**
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ */
+const _readVarStringNative = decoder =>
+  /** @type any */ (utf8TextDecoder).decode(readVarUint8Array(decoder));
+
+/**
+ * Read string of variable length
+ * * varUint is used to store the length of the string
+ *
+ * @function
+ * @param {Decoder} decoder
+ * @return {String} The read String
+ *
+ */
+/* c8 ignore next */
+const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
+
+/**
+ * Utility functions to work with buffers (Uint8Array).
+ *
+ * @module buffer
+ */
+
+/**
+ * Create Uint8Array with initial content from buffer
+ *
+ * @param {ArrayBuffer} buffer
+ * @param {number} byteOffset
+ * @param {number} length
+ */
+const createUint8ArrayViewFromArrayBuffer = (buffer, byteOffset, length) => new Uint8Array(buffer, byteOffset, length);
 
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
@@ -333,7 +514,7 @@ const readVarString = decoder => {
  *
  * ```js
  * // encoding step
- * const encoder = new encoding.createEncoder()
+ * const encoder = encoding.createEncoder()
  * encoding.writeVarUint(encoder, 256)
  * encoding.writeVarString(encoder, 'Hello world!')
  * const buf = encoding.toUint8Array(encoder)
@@ -341,7 +522,7 @@ const readVarString = decoder => {
  *
  * ```js
  * // decoding step
- * const decoder = new decoding.createDecoder(buf)
+ * const decoder = decoding.createDecoder(buf)
  * decoding.readVarUint(decoder) // => 256
  * decoding.readVarString(decoder) // => 'Hello world!'
  * decoding.hasContent(decoder) // => false - all data is read
@@ -368,9 +549,7 @@ const write = (encoder, num) => {
 };
 
 /**
- * Write a variable length unsigned integer.
- *
- * Encodes integers in the range from [0, 4294967295] / [0, 0xffffffff]. (max 32 bit unsigned integer)
+ * Write a variable length unsigned integer. Max encodable integer is 2^53.
  *
  * @function
  * @param {Encoder} encoder
@@ -379,11 +558,38 @@ const write = (encoder, num) => {
 const writeVarUint = (encoder, num) => {
   while (num > BITS7) {
     write(encoder, BIT8 | (BITS7 & num));
-    num >>>= 7;
+    num = floor(num / 128); // shift >>> 7
   }
   write(encoder, BITS7 & num);
 };
 
+/**
+ * A cache to store strings temporarily
+ */
+const _strBuffer = new Uint8Array(30000);
+const _maxStrBSize = _strBuffer.length / 3;
+
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+const _writeVarStringNative = (encoder, str) => {
+  if (str.length < _maxStrBSize) {
+    // We can encode the string into the existing buffer
+    /* c8 ignore next */
+    const written = utf8TextEncoder.encodeInto(str, _strBuffer).written || 0;
+    writeVarUint(encoder, written);
+    for (let i = 0; i < written; i++) {
+      write(encoder, _strBuffer[i]);
+    }
+  } else {
+    writeVarUint8Array(encoder, encodeUtf8(str));
+  }
+};
+
 /**
  * Write a variable length string.
  *
@@ -391,7 +597,7 @@ const writeVarUint = (encoder, num) => {
  * @param {Encoder} encoder
  * @param {String} str The string that is to be encoded.
  */
-const writeVarString = (encoder, str) => {
+const _writeVarStringPolyfill = (encoder, str) => {
   const encodedString = unescape(encodeURIComponent(str));
   const len = encodedString.length;
   writeVarUint(encoder, len);
@@ -400,6 +606,54 @@ const writeVarString = (encoder, str) => {
   }
 };
 
+/**
+ * Write a variable length string.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {String} str The string that is to be encoded.
+ */
+/* c8 ignore next */
+const writeVarString = (utf8TextEncoder && /** @type {any} */ (utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill;
+
+/**
+ * Append fixed-length Uint8Array to the encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeUint8Array = (encoder, uint8Array) => {
+  const bufferLen = encoder.cbuf.length;
+  const cpos = encoder.cpos;
+  const leftCopyLen = min(bufferLen - cpos, uint8Array.length);
+  const rightCopyLen = uint8Array.length - leftCopyLen;
+  encoder.cbuf.set(uint8Array.subarray(0, leftCopyLen), cpos);
+  encoder.cpos += leftCopyLen;
+  if (rightCopyLen > 0) {
+    // Still something to write, write right half..
+    // Append new buffer
+    encoder.bufs.push(encoder.cbuf);
+    // must have at least size of remaining buffer
+    encoder.cbuf = new Uint8Array(max(bufferLen * 2, rightCopyLen));
+    // copy array
+    encoder.cbuf.set(uint8Array.subarray(leftCopyLen));
+    encoder.cpos = rightCopyLen;
+  }
+};
+
+/**
+ * Append an Uint8Array to Encoder.
+ *
+ * @function
+ * @param {Encoder} encoder
+ * @param {Uint8Array} uint8Array
+ */
+const writeVarUint8Array = (encoder, uint8Array) => {
+  writeVarUint(encoder, uint8Array.byteLength);
+  writeUint8Array(encoder, uint8Array);
+};
+
 var AuthMessageType;
 (function (AuthMessageType) {
     AuthMessageType[AuthMessageType["Token"] = 0] = "Token";