@nice2dev/ui-graphics 1.3.14 → 1.3.16

package/dist/esm/node_modules/lib0/decoding.js

@@ -1,370 +1,200 @@
-import { BIT8, BITS7, BIT7, BITS6 } from './binary.js';
-import { floor, isNegativeZero } from './math.js';
-import { MAX_SAFE_INTEGER } from './number.js';
-import { utf8TextDecoder } from './string.js';
-import { create } from './error.js';
-
-/**
- * Efficient schema-less binary decoding with support for variable length encoding.
- *
- * Use [lib0/decoding] with [lib0/encoding]. Every encoding function has a corresponding decoding function.
- *
- * Encodes numbers in little-endian order (least to most significant byte order)
- * and is compatible with Golang's binary encoding (https://golang.org/pkg/encoding/binary/)
- * which is also used in Protocol Buffers.
- *
- * ```js
- * // encoding step
- * const encoder = encoding.createEncoder()
- * encoding.writeVarUint(encoder, 256)
- * encoding.writeVarString(encoder, 'Hello world!')
- * const buf = encoding.toUint8Array(encoder)
- * ```
- *
- * ```js
- * // decoding step
- * const decoder = decoding.createDecoder(buf)
- * decoding.readVarUint(decoder) // => 256
- * decoding.readVarString(decoder) // => 'Hello world!'
- * decoding.hasContent(decoder) // => false - all data is read
- * ```
- *
- * @module decoding
- */
-
-
-const errorUnexpectedEndOfArray = create('Unexpected end of array');
-const errorIntegerOutOfRange = create('Integer out of Range');
-
-/**
- * A Decoder handles the decoding of an Uint8Array.
- * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
- */
+import { BIT8, BITS7, BIT7, BITS6 } from "./binary.js";
+import { floor, isNegativeZero } from "./math.js";
+import { MAX_SAFE_INTEGER } from "./number.js";
+import { utf8TextDecoder } from "./string.js";
+import { create } from "./error.js";
+const errorUnexpectedEndOfArray = create("Unexpected end of array");
+const errorIntegerOutOfRange = create("Integer out of Range");
+const subarray = (arr, begin, len) => {
+  if (begin < 0 || len < 0 || begin + len > arr.length) {
+    throw errorUnexpectedEndOfArray;
+  }
+  return new Uint8Array(arr.buffer, arr.byteOffset + begin, len);
+};
+const subdataview = (arr, begin, len) => {
+  if (begin < 0 || len < 0 || begin + len > arr.length) {
+    throw errorUnexpectedEndOfArray;
+  }
+  return new DataView(arr.buffer, arr.byteOffset + begin, len);
+};
 class Decoder {
   /**
    * @param {Uint8Array<Buf>} uint8Array Binary data to decode
    */
-  constructor (uint8Array) {
-    /**
-     * Decoding target.
-     *
-     * @type {Uint8Array<Buf>}
-     */
+  constructor(uint8Array) {
     this.arr = uint8Array;
-    /**
-     * Current decoding position.
-     *
-     * @type {number}
-     */
     this.pos = 0;
   }
 }
-
-/**
- * @function
- * @template {ArrayBufferLike} Buf
- * @param {Uint8Array<Buf>} uint8Array
- * @return {Decoder<Buf>}
- */
-const createDecoder = uint8Array => new Decoder(uint8Array);
-
-/**
- * @function
- * @param {Decoder} decoder
- * @return {boolean}
- */
-const hasContent = decoder => decoder.pos !== decoder.arr.length;
-
-/**
- * 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
- * @template {ArrayBufferLike} Buf
- * @param {Decoder<Buf>} decoder The decoder instance
- * @param {number} len The length of bytes to read
- * @return {Uint8Array<Buf>}
- */
+const createDecoder = (uint8Array) => new Decoder(uint8Array);
+const hasContent = (decoder) => decoder.pos !== decoder.arr.length;
 const readUint8Array = (decoder, len) => {
-  const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
+  const view = subarray(decoder.arr, decoder.pos, len);
   decoder.pos += len;
-  return view
+  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
- * @template {ArrayBufferLike} Buf
- * @param {Decoder<Buf>} decoder
- * @return {Uint8Array<Buf>}
- */
-const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
-
-/**
- * Read one byte as unsigned integer.
- * @function
- * @param {Decoder} decoder The decoder instance
- * @return {number} Unsigned 8-bit integer
- */
-const readUint8 = decoder => decoder.arr[decoder.pos++];
-
-/**
- * Read unsigned integer (32bit) with variable length.
- * 1/8th of the storage is used as encoding overhead.
- *  * numbers < 2^7 is stored in one bytlength
- *  * numbers < 2^14 is stored in two bylength
- *
- * @function
- * @param {Decoder} decoder
- * @return {number} An unsigned integer.length
- */
-const readVarUint = decoder => {
+const readVarUint8Array = (decoder) => readUint8Array(decoder, readVarUint(decoder));
+const readUint8 = (decoder) => decoder.arr[decoder.pos++];
+const readVarUint = (decoder) => {
   let num = 0;
   let mult = 1;
   const len = decoder.arr.length;
   while (decoder.pos < len) {
     const r = decoder.arr[decoder.pos++];
-    // 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
+    num = num + (r & BITS7) * mult;
+    mult *= 128;
     if (r < BIT8) {
-      return num
+      return num;
     }
-    /* c8 ignore start */
     if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange
+      throw errorIntegerOutOfRange;
     }
-    /* c8 ignore stop */
   }
-  throw errorUnexpectedEndOfArray
+  throw errorUnexpectedEndOfArray;
 };
-
-/**
- * Read signed integer (32bit) with variable length.
- * 1/8th of the storage is used as encoding overhead.
- *  * numbers < 2^7 is stored in one bytlength
- *  * numbers < 2^14 is stored in two bylength
- * @todo This should probably create the inverse ~num if number is negative - but this would be a breaking change.
- *
- * @function
- * @param {Decoder} decoder
- * @return {number} An unsigned integer.length
- */
-const readVarInt = decoder => {
+const readVarInt = (decoder) => {
   let r = decoder.arr[decoder.pos++];
   let num = r & BITS6;
   let mult = 64;
   const sign = (r & BIT7) > 0 ? -1 : 1;
   if ((r & BIT8) === 0) {
-    // don't continue reading
-    return sign * num
+    return sign * num;
   }
   const len = decoder.arr.length;
   while (decoder.pos < len) {
     r = decoder.arr[decoder.pos++];
-    // num = num | ((r & binary.BITS7) << len)
     num = num + (r & BITS7) * mult;
     mult *= 128;
     if (r < BIT8) {
-      return sign * num
+      return sign * num;
     }
-    /* c8 ignore start */
     if (num > MAX_SAFE_INTEGER) {
-      throw errorIntegerOutOfRange
+      throw errorIntegerOutOfRange;
     }
-    /* c8 ignore stop */
   }
-  throw errorUnexpectedEndOfArray
+  throw errorUnexpectedEndOfArray;
 };
-
-/**
- * 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.
- * But most environments have a maximum number of arguments per functions.
- * For effiency reasons we apply a maximum of 10000 characters at once.
- *
- * @function
- * @param {Decoder} decoder
- * @return {String} The read String.
- */
-/* c8 ignore start */
-const _readVarStringPolyfill = decoder => {
+const _readVarStringPolyfill = (decoder) => {
   let remainingLen = readVarUint(decoder);
   if (remainingLen === 0) {
-    return ''
+    return "";
   } else {
-    let encodedString = String.fromCodePoint(readUint8(decoder)); // remember to decrease remainingLen
-    if (--remainingLen < 100) { // do not create a Uint8Array for small strings
+    let encodedString = String.fromCodePoint(readUint8(decoder));
+    if (--remainingLen < 100) {
       while (remainingLen--) {
         encodedString += String.fromCodePoint(readUint8(decoder));
       }
     } else {
       while (remainingLen > 0) {
-        const nextLen = remainingLen < 10000 ? remainingLen : 10000;
-        // this is dangerous, we create a fresh array view from the existing buffer
+        const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
         const bytes = decoder.arr.subarray(decoder.pos, decoder.pos + nextLen);
         decoder.pos += nextLen;
-        // Starting with ES5.1 we can supply a generic array-like object as arguments
-        encodedString += String.fromCodePoint.apply(null, /** @type {any} */ (bytes));
+        encodedString += String.fromCodePoint.apply(
+          null,
+          /** @type {any} */
+          bytes
+        );
         remainingLen -= nextLen;
       }
     }
-    return decodeURIComponent(escape(encodedString))
+    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 _readVarStringNative = (decoder) => (
+  /** @type any */
+  utf8TextDecoder.decode(readVarUint8Array(decoder))
+);
 const readVarString = utf8TextDecoder ? _readVarStringNative : _readVarStringPolyfill;
-
-/**
- * @param {Decoder} decoder
- * @param {number} len
- * @return {DataView}
- */
 const readFromDataView = (decoder, len) => {
-  const dv = new DataView(decoder.arr.buffer, decoder.arr.byteOffset + decoder.pos, len);
+  const dv = subdataview(decoder.arr, decoder.pos, len);
   decoder.pos += len;
-  return dv
+  return dv;
 };
-
-/**
- * @param {Decoder} decoder
- */
-const readFloat32 = decoder => readFromDataView(decoder, 4).getFloat32(0, false);
-
-/**
- * @param {Decoder} decoder
- */
-const readFloat64 = decoder => readFromDataView(decoder, 8).getFloat64(0, false);
-
-/**
- * @param {Decoder} decoder
- */
-const readBigInt64 = decoder => /** @type {any} */ (readFromDataView(decoder, 8)).getBigInt64(0, false);
-
-/**
- * @type {Array<function(Decoder):any>}
- */
+const readFloat32 = (decoder) => readFromDataView(decoder, 4).getFloat32(0, false);
+const readFloat64 = (decoder) => readFromDataView(decoder, 8).getFloat64(0, false);
+const readBigInt64 = (decoder) => (
+  /** @type {any} */
+  readFromDataView(decoder, 8).getBigInt64(0, false)
+);
 const readAnyLookupTable = [
-  decoder => undefined, // CASE 127: undefined
-  decoder => null, // CASE 126: null
-  readVarInt, // CASE 125: integer
-  readFloat32, // CASE 124: float32
-  readFloat64, // CASE 123: float64
-  readBigInt64, // CASE 122: bigint
-  decoder => false, // CASE 121: boolean (false)
-  decoder => true, // CASE 120: boolean (true)
-  readVarString, // CASE 119: string
-  decoder => { // CASE 118: object<string,any>
+  (decoder) => void 0,
+  // CASE 127: undefined
+  (decoder) => null,
+  // CASE 126: null
+  readVarInt,
+  // CASE 125: integer
+  readFloat32,
+  // CASE 124: float32
+  readFloat64,
+  // CASE 123: float64
+  readBigInt64,
+  // CASE 122: bigint
+  (decoder) => false,
+  // CASE 121: boolean (false)
+  (decoder) => true,
+  // CASE 120: boolean (true)
+  readVarString,
+  // CASE 119: string
+  (decoder) => {
     const len = readVarUint(decoder);
-    /**
-     * @type {Object<string,any>}
-     */
     const obj = {};
     for (let i = 0; i < len; i++) {
       const key = readVarString(decoder);
       obj[key] = readAny(decoder);
     }
-    return obj
+    return obj;
   },
-  decoder => { // CASE 117: array<any>
+  (decoder) => {
     const len = readVarUint(decoder);
     const arr = [];
     for (let i = 0; i < len; i++) {
       arr.push(readAny(decoder));
     }
-    return arr
+    return arr;
   },
-  readVarUint8Array // CASE 116: Uint8Array
+  readVarUint8Array
+  // CASE 116: Uint8Array
 ];
-
-/**
- * @param {Decoder} decoder
- */
-const readAny = decoder => readAnyLookupTable[127 - readUint8(decoder)](decoder);
-
-/**
- * T must not be null.
- *
- * @template T
- */
+const readAny = (decoder) => readAnyLookupTable[127 - readUint8(decoder)](decoder);
 class RleDecoder extends Decoder {
   /**
    * @param {Uint8Array} uint8Array
    * @param {function(Decoder):T} reader
    */
-  constructor (uint8Array, reader) {
+  constructor(uint8Array, reader) {
     super(uint8Array);
-    /**
-     * The reader
-     */
     this.reader = reader;
-    /**
-     * Current state
-     * @type {T|null}
-     */
     this.s = null;
     this.count = 0;
   }
-
-  read () {
+  read() {
     if (this.count === 0) {
       this.s = this.reader(this);
       if (hasContent(this)) {
-        this.count = readVarUint(this) + 1; // see encoder implementation for the reason why this is incremented
+        this.count = readVarUint(this) + 1;
       } else {
-        this.count = -1; // read the current value forever
+        this.count = -1;
       }
     }
     this.count--;
-    return /** @type {T} */ (this.s)
+    return (
+      /** @type {T} */
+      this.s
+    );
   }
 }
-
 class UintOptRleDecoder extends Decoder {
   /**
    * @param {Uint8Array} uint8Array
    */
-  constructor (uint8Array) {
+  constructor(uint8Array) {
     super(uint8Array);
-    /**
-     * @type {number}
-     */
     this.s = 0;
     this.count = 0;
   }
-
-  read () {
+  read() {
     if (this.count === 0) {
       this.s = readVarInt(this);
-      // if the sign is negative, we read the count too, otherwise count is 1
       const isNegative = isNegativeZero(this.s);
       this.count = 1;
       if (isNegative) {
@@ -373,33 +203,30 @@ class UintOptRleDecoder extends Decoder {
       }
     }
     this.count--;
-    return /** @type {number} */ (this.s)
+    return (
+      /** @type {number} */
+      this.s
+    );
   }
 }
-
 class IntDiffOptRleDecoder extends Decoder {
   /**
    * @param {Uint8Array} uint8Array
    */
-  constructor (uint8Array) {
+  constructor(uint8Array) {
     super(uint8Array);
-    /**
-     * @type {number}
-     */
     this.s = 0;
     this.count = 0;
     this.diff = 0;
   }
-
   /**
    * @return {number}
    */
-  read () {
+  read() {
     if (this.count === 0) {
       const diff = readVarInt(this);
-      // if the first bit is set, we read more data
       const hasCount = diff & 1;
-      this.diff = floor(diff / 2); // shift >> 1
+      this.diff = floor(diff / 2);
       this.count = 1;
       if (hasCount) {
         this.count = readVarUint(this) + 2;
@@ -407,32 +234,47 @@ class IntDiffOptRleDecoder extends Decoder {
     }
     this.s += this.diff;
     this.count--;
-    return this.s
+    return this.s;
   }
 }
-
 class StringDecoder {
   /**
    * @param {Uint8Array} uint8Array
    */
-  constructor (uint8Array) {
+  constructor(uint8Array) {
     this.decoder = new UintOptRleDecoder(uint8Array);
     this.str = readVarString(this.decoder);
-    /**
-     * @type {number}
-     */
     this.spos = 0;
   }
-
   /**
    * @return {string}
    */
-  read () {
+  read() {
     const end = this.spos + this.decoder.read();
     const res = this.str.slice(this.spos, end);
     this.spos = end;
-    return res
+    return res;
   }
 }
-
-export { Decoder, IntDiffOptRleDecoder, RleDecoder, StringDecoder, UintOptRleDecoder, _readVarStringNative, _readVarStringPolyfill, createDecoder, hasContent, readAny, readBigInt64, readFloat32, readFloat64, readFromDataView, readUint8, readUint8Array, readVarInt, readVarString, readVarUint, readVarUint8Array };
+export {
+  Decoder,
+  IntDiffOptRleDecoder,
+  RleDecoder,
+  StringDecoder,
+  UintOptRleDecoder,
+  _readVarStringNative,
+  _readVarStringPolyfill,
+  createDecoder,
+  hasContent,
+  readAny,
+  readBigInt64,
+  readFloat32,
+  readFloat64,
+  readFromDataView,
+  readUint8,
+  readUint8Array,
+  readVarInt,
+  readVarString,
+  readVarUint,
+  readVarUint8Array
+};

package/dist/esm/node_modules/lib0/dom.js

@@ -1,47 +1,24 @@
-import { map } from './map.js';
-import { $custom } from './schema.js';
-
-/* eslint-env browser */
-
-
-/* c8 ignore start */
-/**
- * @type {Document}
- */
-const doc = /** @type {Document} */ (typeof document !== 'undefined' ? document : {});
-
-/**
- * @type {$.Schema<DocumentFragment>}
- */
-$custom(el => el.nodeType === DOCUMENT_FRAGMENT_NODE);
-
-/** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
-
-/**
- * @type {$.Schema<Element>}
- */
-$custom(el => el.nodeType === ELEMENT_NODE);
-
-/**
- * @type {$.Schema<Text>}
- */
-$custom(el => el.nodeType === TEXT_NODE);
-
-/**
- * @param {Map<string,string>} m
- * @return {string}
- */
-const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join('');
-
+import { map } from "./map.js";
+import { $custom } from "./schema.js";
+const doc = (
+  /** @type {Document} */
+  typeof document !== "undefined" ? document : {}
+);
+$custom((el) => el.nodeType === DOCUMENT_FRAGMENT_NODE);
+typeof DOMParser !== "undefined" ? new DOMParser() : null;
+$custom((el) => el.nodeType === ELEMENT_NODE);
+$custom((el) => el.nodeType === TEXT_NODE);
+const mapToStyleString = (m) => map(m, (value, key) => `${key}:${value};`).join("");
 const ELEMENT_NODE = doc.ELEMENT_NODE;
 const TEXT_NODE = doc.TEXT_NODE;
 const DOCUMENT_NODE = doc.DOCUMENT_NODE;
 const DOCUMENT_FRAGMENT_NODE = doc.DOCUMENT_FRAGMENT_NODE;
-
-/**
- * @type {$.Schema<Node>}
- */
-$custom(el => el.nodeType === DOCUMENT_NODE);
-/* c8 ignore stop */
-
-export { DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, ELEMENT_NODE, TEXT_NODE, doc, mapToStyleString };
+$custom((el) => el.nodeType === DOCUMENT_NODE);
+export {
+  DOCUMENT_FRAGMENT_NODE,
+  DOCUMENT_NODE,
+  ELEMENT_NODE,
+  TEXT_NODE,
+  doc,
+  mapToStyleString
+};