kritzel-stencil 0.0.172 → 0.1.0

package/dist/esm/{default-line-tool.config-CuBm2vpW.js → default-line-tool.config-CD5sTKH-.js}

@@ -3028,7 +3028,7 @@ creating and deserializing such documents.
 When given, the type parameters provide the names of the nodes and
 marks in this schema.
 */
-class Schema {
+let Schema$1 = class Schema {
     /**
     Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
     */
@@ -3120,7 +3120,7 @@ class Schema {
             throw new RangeError("Unknown node type: " + name);
         return found;
     }
-}
+};
 function gatherMarks(schema, marks) {
     let found = [];
     for (let i = 0; i < marks.length; i++) {
@@ -3887,7 +3887,7 @@ class DOMSerializer {
     */
     serializeFragment(fragment, options = {}, target) {
         if (!target)
-            target = doc$1(options).createDocumentFragment();
+            target = doc$2(options).createDocumentFragment();
         let top = target, active = [];
         fragment.forEach(node => {
             if (active.length || node.marks.length) {
@@ -3923,7 +3923,7 @@ class DOMSerializer {
     @internal
     */
     serializeNodeInner(node, options) {
-        let { dom, contentDOM } = renderSpec(doc$1(options), this.nodes[node.type.name](node), null, node.attrs);
+        let { dom, contentDOM } = renderSpec(doc$2(options), this.nodes[node.type.name](node), null, node.attrs);
         if (contentDOM) {
             if (node.isLeaf)
                 throw new RangeError("Content hole not allowed in a leaf node spec");
@@ -3954,7 +3954,7 @@ class DOMSerializer {
     */
     serializeMark(mark, inline, options = {}) {
         let toDOM = this.marks[mark.type.name];
-        return toDOM && renderSpec(doc$1(options), toDOM(mark, inline), null, mark.attrs);
+        return toDOM && renderSpec(doc$2(options), toDOM(mark, inline), null, mark.attrs);
     }
     static renderSpec(doc, structure, xmlNS = null, blockArraysIn) {
         return renderSpec(doc, structure, xmlNS, blockArraysIn);
@@ -3993,7 +3993,7 @@ function gatherToDOM(obj) {
     }
     return result;
 }
-function doc$1(options) {
+function doc$2(options) {
     return options.document || window.document;
 }
 const suspiciousAttributeCache = new WeakMap();
@@ -7307,7 +7307,7 @@ function caretFromPoint(doc, x, y) {
 }
 
 const nav = typeof navigator != "undefined" ? navigator : null;
-const doc = typeof document != "undefined" ? document : null;
+const doc$1 = typeof document != "undefined" ? document : null;
 const agent = (nav && nav.userAgent) || "";
 const ie_edge = /Edge\/(\d+)/.exec(agent);
 const ie_upto10 = /MSIE \d/.exec(agent);
@@ -7324,7 +7324,7 @@ const ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints
 const mac$3 = ios || (nav ? /Mac/.test(nav.platform) : false);
 const windows$1 = nav ? /Win/.test(nav.platform) : false;
 const android = /Android \d/.test(agent);
-const webkit = !!doc && "webkitFontSmoothing" in doc.documentElement.style;
+const webkit = !!doc$1 && "webkitFontSmoothing" in doc$1.documentElement.style;
 const webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
 
 function windowRect(doc) {
@@ -7510,17 +7510,20 @@ function findOffsetInNode(node, coords) {
 }
 function findOffsetInText(node, coords) {
     let len = node.nodeValue.length;
-    let range = document.createRange();
+    let range = document.createRange(), result;
     for (let i = 0; i < len; i++) {
         range.setEnd(node, i + 1);
         range.setStart(node, i);
         let rect = singleRect(range, 1);
         if (rect.top == rect.bottom)
             continue;
-        if (inRect(coords, rect))
-            return { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+        if (inRect(coords, rect)) {
+            result = { node, offset: i + (coords.left >= (rect.left + rect.right) / 2 ? 1 : 0) };
+            break;
+        }
     }
-    return { node, offset: 0 };
+    range.detach();
+    return result || { node, offset: 0 };
 }
 function inRect(coords, rect) {
     return coords.left >= rect.left - 1 && coords.left <= rect.right + 1 &&
@@ -10613,7 +10616,8 @@ editHandlers.compositionstart = editHandlers.compositionupdate = view => {
         let { state } = view, $pos = state.selection.$to;
         if (state.selection instanceof TextSelection &&
             (state.storedMarks ||
-                (!$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some(m => m.type.spec.inclusive === false)))) {
+                (!$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some(m => m.type.spec.inclusive === false)) ||
+                chrome && windows$1 && selectionBeforeUneditable(view))) { // Issue #1500
             // Need to wrap the cursor in mark nodes different from the ones in the DOM context
             view.markCursor = view.state.storedMarks || $pos.marks();
             endComposition(view, true);
@@ -10647,6 +10651,13 @@ editHandlers.compositionstart = editHandlers.compositionupdate = view => {
     }
     scheduleComposeEnd(view, timeoutComposition);
 };
+function selectionBeforeUneditable(view) {
+    let { focusNode, focusOffset } = view.domSelectionRange();
+    if (!focusNode || focusNode.nodeType != 1 || focusOffset >= focusNode.childNodes.length)
+        return false;
+    let next = focusNode.childNodes[focusOffset];
+    return next.nodeType == 1 && next.contentEditable == "false";
+}
 editHandlers.compositionend = (view, event) => {
     if (view.composing) {
         view.input.composing = false;
@@ -10874,10 +10885,15 @@ handlers.dragend = view => {
     }, 50);
 };
 editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
-editHandlers.drop = (view, _event) => {
-    let event = _event;
-    let dragging = view.dragging;
-    view.dragging = null;
+editHandlers.drop = (view, event) => {
+    try {
+        handleDrop(view, event, view.dragging);
+    }
+    finally {
+        view.dragging = null;
+    }
+};
+function handleDrop(view, event, dragging) {
     if (!event.dataTransfer)
         return;
     let eventPos = view.posAtCoords(eventCoords(event));
@@ -10931,7 +10947,7 @@ editHandlers.drop = (view, _event) => {
     }
     view.focus();
     view.dispatch(tr.setMeta("uiEvent", "drop"));
-};
+}
 handlers.focus = view => {
     view.input.lastFocus = Date.now();
     if (!view.focused) {
@@ -11857,6 +11873,17 @@ class DOMObserver {
                 }
             }
         }
+        else if ((chrome || safari) && added.some(n => n.nodeName == "BR") &&
+            (view.input.lastKeyCode == 8 || view.input.lastKeyCode == 46)) {
+            // Chrome/Safari sometimes insert a bogus break node if you
+            // backspace out the last bit of text before an inline-flex node (#1552)
+            for (let node of added)
+                if (node.nodeName == "BR" && node.parentNode) {
+                    let after = node.nextSibling;
+                    if (after && after.nodeType == 1 && after.contentEditable == "false")
+                        node.parentNode.removeChild(node);
+                }
+        }
         let readSel = null;
         // If it looks like the browser has reset the selection to the
         // start of the document after focus, restore the selection from
@@ -13131,7 +13158,7 @@ module.
 To reuse elements from this schema, extend or read from its
 `spec.nodes` and `spec.marks` [properties](https://prosemirror.net/docs/ref/#model.Schema.spec).
 */
-const schema = new Schema({ nodes, marks });
+const schema = new Schema$1({ nodes, marks });
 
 const olDOM = ["ol", 0], ulDOM = ["ul", 0], liDOM = ["li", 0];
 /**
@@ -13959,7 +13986,7 @@ class KritzelText extends KritzelBaseObject {
     isEditing = false;
     editor = null;
     content = null;
-    _schema = new Schema({
+    _schema = new Schema$1({
         nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block'),
         marks: schema.spec.marks,
     });
@@ -18147,6 +18174,12 @@ class KritzelSelectionTool extends KritzelBaseTool {
  * @module map
  */
 
+/**
+ * @template K
+ * @template V
+ * @typedef {Map<K,V>} GlobalMap
+ */
+
 /**
  * Creates a new Map instance.
  *
@@ -18282,6 +18315,25 @@ const appendTo = (dest, src) => {
  */
 const from$1 = Array.from;
 
+/**
+ * True iff condition holds on every element in the Array.
+ *
+ * @function
+ * @template {ArrayLike<any>} ARR
+ *
+ * @param {ARR} arr
+ * @param {ARR extends ArrayLike<infer S> ? ((value:S, index:number, arr:ARR) => boolean) : any} f
+ * @return {boolean}
+ */
+const every$1 = (arr, f) => {
+  for (let i = 0; i < arr.length; i++) {
+    if (!f(arr[i], i, arr)) {
+      return false
+    }
+  }
+  return true
+};
+
 /**
  * True iff condition holds on some element in the Array.
  *
@@ -18301,6 +18353,20 @@ const some = (arr, f) => {
   return false
 };
 
+/**
+ * @template T
+ * @param {number} len
+ * @param {function(number, Array<T>):T} f
+ * @return {Array<T>}
+ */
+const unfold = (len, f) => {
+  const array = new Array(len);
+  for (let i = 0; i < len; i++) {
+    array[i] = f(i, array);
+  }
+  return array
+};
+
 const isArray = Array.isArray;
 
 /**
@@ -18490,8 +18556,10 @@ const max$2 = (a, b) => a > b ? a : b;
 const pow = Math.pow;
 
 /**
+ * Check whether n is negative, while considering the -0 edge case. While `-0 < 0` is false, this
+ * function returns true for -0,-1,,.. and returns false for 0,1,2,...
  * @param {number} n
- * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0
+ * @return {boolean} Wether n is negative. This function also distinguishes between -0 and +0
  */
 const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
 
@@ -18531,6 +18599,7 @@ const BITS31 = 0x7FFFFFFF;
 
 
 const MAX_SAFE_INTEGER$2 = Number.MAX_SAFE_INTEGER;
+const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
 
 /* c8 ignore next */
 const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor$2(num) === num);
@@ -18568,7 +18637,7 @@ const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, m
 
 /**
  * @param {string} str
- * @return {Uint8Array}
+ * @return {Uint8Array<ArrayBuffer>}
  */
 const _encodeUtf8Polyfill$2 = str => {
   const encodedString = unescape(encodeURIComponent(str));
@@ -18585,7 +18654,7 @@ const utf8TextEncoder$2 = /** @type {TextEncoder} */ (typeof TextEncoder !== 'un
 
 /**
  * @param {string} str
- * @return {Uint8Array}
+ * @return {Uint8Array<ArrayBuffer>}
  */
 const _encodeUtf8Native$2 = str => utf8TextEncoder$2.encode(str);
 
@@ -18610,6 +18679,12 @@ if (utf8TextDecoder$2 && utf8TextDecoder$2.decode(new Uint8Array()).length === 1
   utf8TextDecoder$2 = null;
 }
 
+/**
+ * @param {string} source
+ * @param {number} n
+ */
+const repeat = (source, n) => unfold(n, () => source).join('');
+
 /**
  * Efficient schema-less binary encoding with support for variable length encoding.
  *
@@ -18666,7 +18741,7 @@ const createEncoder$1 = () => new Encoder$1();
  * @param {Encoder} encoder
  * @return {number}
  */
-const length$3 = encoder => {
+const length$2 = encoder => {
   let len = encoder.cpos;
   for (let i = 0; i < encoder.bufs.length; i++) {
     len += encoder.bufs[i].length;
@@ -18679,10 +18754,10 @@ const length$3 = encoder => {
  *
  * @function
  * @param {Encoder} encoder
- * @return {Uint8Array} The created ArrayBuffer.
+ * @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
  */
 const toUint8Array$1 = encoder => {
-  const uint8arr = new Uint8Array(length$3(encoder));
+  const uint8arr = new Uint8Array(length$2(encoder));
   let curPos = 0;
   for (let i = 0; i < encoder.bufs.length; i++) {
     const d = encoder.bufs[i];
@@ -18920,6 +18995,14 @@ const isFloat32 = num => {
   return floatTestBed.getFloat32(0) === num
 };
 
+/**
+ * @typedef {Array<AnyEncodable>} AnyEncodableArray
+ */
+
+/**
+ * @typedef {undefined|null|number|bigint|boolean|string|{[k:string]:AnyEncodable}|AnyEncodableArray|Uint8Array} AnyEncodable
+ */
+
 /**
  * Encode data with efficient binary format.
  *
@@ -18955,7 +19038,7 @@ const isFloat32 = num => {
  *          lib0/encoding.js
  *
  * @param {Encoder} encoder
- * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
+ * @param {AnyEncodable} data
  */
 const writeAny = (encoder, data) => {
   switch (typeof data) {
@@ -19309,16 +19392,17 @@ const errorIntegerOutOfRange$2 = create$7('Integer out of Range');
 
 /**
  * A Decoder handles the decoding of an Uint8Array.
+ * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
  */
 let Decoder$1 = class Decoder {
   /**
-   * @param {Uint8Array} uint8Array Binary data to decode
+   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
    */
   constructor (uint8Array) {
     /**
      * Decoding target.
      *
-     * @type {Uint8Array}
+     * @type {Uint8Array<Buf>}
      */
     this.arr = uint8Array;
     /**
@@ -19332,8 +19416,9 @@ let Decoder$1 = class Decoder {
 
 /**
  * @function
- * @param {Uint8Array} uint8Array
- * @return {Decoder}
+ * @template {ArrayBufferLike} Buf
+ * @param {Uint8Array<Buf>} uint8Array
+ * @return {Decoder<Buf>}
  */
 const createDecoder$1 = uint8Array => new Decoder$1(uint8Array);
 
@@ -19351,9 +19436,10 @@ const hasContent = decoder => decoder.pos !== decoder.arr.length;
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @param {Decoder} decoder The decoder instance
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder The decoder instance
  * @param {number} len The length of bytes to read
- * @return {Uint8Array}
+ * @return {Uint8Array<Buf>}
  */
 const readUint8Array$2 = (decoder, len) => {
   const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
@@ -19368,8 +19454,9 @@ const readUint8Array$2 = (decoder, len) => {
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @param {Decoder} decoder
- * @return {Uint8Array}
+ * @template {ArrayBufferLike} Buf
+ * @param {Decoder<Buf>} decoder
+ * @return {Uint8Array<Buf>}
  */
 const readVarUint8Array$2 = decoder => readUint8Array$2(decoder, readVarUint$2(decoder));
 
@@ -19857,12 +19944,38 @@ const onChange = eventHandler => usePolyfill || addEventListener('storage', /**
 /* c8 ignore next */
 const offChange = eventHandler => usePolyfill || removeEventListener('storage', /** @type {any} */ (eventHandler));
 
+const EqualityTraitSymbol = Symbol('Equality');
+
+/**
+ * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
+ */
+
 /**
- * Utility functions for working with EcmaScript objects.
  *
- * @module object
+ * Utility function to compare any two objects.
+ *
+ * Note that it is expected that the first parameter is more specific than the latter one.
+ *
+ * @example js
+ *     class X { [traits.EqualityTraitSymbol] (other) { return other === this }  }
+ *     class X2 { [traits.EqualityTraitSymbol] (other) { return other === this }, x2 () { return 2 }  }
+ *     // this is fine
+ *     traits.equals(new X2(), new X())
+ *     // this is not, because the left type is less specific than the right one
+ *     traits.equals(new X(), new X2())
+ *
+ * @template {EqualityTrait} T
+ * @param {NoInfer<T>} a
+ * @param {T} b
+ * @return {boolean}
  */
+const equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
 
+/**
+ * @param {any} o
+ * @return {o is { [k:string]:any }}
+ */
+const isObject = o => typeof o === 'object';
 
 /**
  * Object.assign
@@ -19901,13 +20014,6 @@ const map = (obj, f) => {
   return results
 };
 
-/**
- * @deprecated use object.size instead
- * @param {Object<string,any>} obj
- * @return {number}
- */
-const length$2 = obj => keys$1(obj).length;
-
 /**
  * @param {Object<string,any>} obj
  * @return {number}
@@ -19954,7 +20060,7 @@ const hasProperty$1 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, ke
  * @param {Object<string,any>} b
  * @return {boolean}
  */
-const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty$1(b, key)) && b[key] === val));
+const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty$1(b, key)) && equals(b[key], val)));
 
 /**
  * Make an object immutable. This hurts performance and is usually not needed if you perform good
@@ -19980,12 +20086,6 @@ const deepFreeze = (o) => {
   return freeze(o)
 };
 
-const EqualityTraitSymbol = Symbol('Equality');
-
-/**
- * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
- */
-
 /**
  * Common functions and function call helpers.
  *
@@ -20030,7 +20130,7 @@ const equalityDeep$1 = (a, b) => {
   if (a === b) {
     return true
   }
-  if (a == null || b == null || a.constructor !== b.constructor) {
+  if (a == null || b == null || (a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object))) {
     return false
   }
   if (a[EqualityTraitSymbol] != null) {
@@ -20074,8 +20174,9 @@ const equalityDeep$1 = (a, b) => {
       }
       break
     }
+    case undefined:
     case Object:
-      if (length$2(a) !== length$2(b)) {
+      if (size(a) !== size(b)) {
         return false
       }
       for (const key in a) {
@@ -20197,7 +20298,7 @@ const hasConf = (name) =>
   hasParam('--' + name) || getVariable(name) !== null;
 
 /* c8 ignore next */
-hasConf('production');
+const production = hasConf('production');
 
 /* c8 ignore next 2 */
 const forceColor = isNode &&
@@ -20275,7 +20376,7 @@ const toBase64Node = bytes => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.
 /* c8 ignore start */
 /**
  * @param {string} s
- * @return {Uint8Array}
+ * @return {Uint8Array<ArrayBuffer>}
  */
 const fromBase64Browser = s => {
   // eslint-disable-next-line no-undef
@@ -20342,182 +20443,1396 @@ class Pair {
  */
 const create$5 = (left, right) => new Pair(left, right);
 
-/* eslint-env browser */
+/**
+ * Fast Pseudo Random Number Generators.
+ *
+ * Given a seed a PRNG generates a sequence of numbers that cannot be reasonably predicted.
+ * Two PRNGs must generate the same random sequence of numbers if  given the same seed.
+ *
+ * @module prng
+ */
 
 
-/** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+/**
+ * Generates a single random bool.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @return {Boolean} A random boolean
+ */
+const bool = gen => (gen.next() >= 0.5);
 
 /**
- * @param {Map<string,string>} m
- * @return {string}
+ * Generates a random integer with 53 bit resolution.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive).
+ * @return {Number} A random integer on [min, max]
  */
-const mapToStyleString = m => map$1(m, (value, key) => `${key}:${value};`).join('');
-/* c8 ignore stop */
+const int53 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
 
 /**
- * Utility module to work with EcmaScript Symbols.
+ * Generates a random integer with 32 bit resolution.
  *
- * @module symbol
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive).
+ * @return {Number} A random integer on [min, max]
  */
+const int32 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
 
 /**
- * Return fresh symbol.
+ * @deprecated
+ * Optimized version of prng.int32. It has the same precision as prng.int32, but should be preferred when
+ * openaring on smaller ranges.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Number} min The lower bound of the allowed return values (inclusive).
+ * @param {Number} max The upper bound of the allowed return values (inclusive). The max inclusive number is `binary.BITS31-1`
+ * @return {Number} A random integer on [min, max]
  */
-const create$4 = Symbol;
+const int31 = (gen, min, max) => int32(gen, min, max);
 
-const BOLD = create$4();
-const UNBOLD = create$4();
-const BLUE = create$4();
-const GREY = create$4();
-const GREEN = create$4();
-const RED = create$4();
-const PURPLE = create$4();
-const ORANGE = create$4();
-const UNCOLOR = create$4();
+/**
+ * @param {PRNG} gen
+ * @return {string} A single letter (a-z)
+ */
+const letter = gen => fromCharCode(int31(gen, 97, 122));
 
-/* c8 ignore start */
 /**
- * @param {Array<undefined|string|Symbol|Object|number|function():any>} args
- * @return {Array<string|object|number|undefined>}
+ * @param {PRNG} gen
+ * @param {number} [minLen=0]
+ * @param {number} [maxLen=20]
+ * @return {string} A random word (0-20 characters) without spaces consisting of letters (a-z)
  */
-const computeNoColorLoggingArgs = args => {
-  if (args.length === 1 && args[0]?.constructor === Function) {
-    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
-  }
-  const strBuilder = [];
-  const logArgs = [];
-  // try with formatting until we find something unsupported
-  let i = 0;
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === undefined) {
-      break
-    } else if (arg.constructor === String || arg.constructor === Number) {
-      strBuilder.push(arg);
-    } else if (arg.constructor === Object) {
-      break
-    }
-  }
-  if (i > 0) {
-    // create logArgs with what we have so far
-    logArgs.push(strBuilder.join(''));
-  }
-  // append the rest
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    if (!(arg instanceof Symbol)) {
-      logArgs.push(arg);
-    }
+const word = (gen, minLen = 0, maxLen = 20) => {
+  const len = int31(gen, minLen, maxLen);
+  let str = '';
+  for (let i = 0; i < len; i++) {
+    str += letter(gen);
   }
-  return logArgs
+  return str
 };
+
+/**
+ * Returns one element of a given array.
+ *
+ * @param {PRNG} gen A random number generator.
+ * @param {Array<T>} array Non empty Array of possible values.
+ * @return {T} One of the values of the supplied Array.
+ * @template T
+ */
+const oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
 /* c8 ignore stop */
 
 /**
- * Isomorphic logging module with support for colors!
+ * @experimental WIP
  *
- * @module logging
+ * Simple & efficient schemas for your data.
  */
 
 
 /**
- * @type {Object<Symbol,pair.Pair<string,string>>}
+ * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
  */
-const _browserStyleMap = {
-  [BOLD]: create$5('font-weight', 'bold'),
-  [UNBOLD]: create$5('font-weight', 'normal'),
-  [BLUE]: create$5('color', 'blue'),
-  [GREEN]: create$5('color', 'green'),
-  [GREY]: create$5('color', 'grey'),
-  [RED]: create$5('color', 'red'),
-  [PURPLE]: create$5('color', 'purple'),
-  [ORANGE]: create$5('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate
-  [UNCOLOR]: create$5('color', 'black')
-};
 
 /**
- * @param {Array<string|Symbol|Object|number|function():any>} args
- * @return {Array<string|object|number>}
+ * @typedef {{ [k:string|number|symbol]: any }} AnyObject
  */
-/* c8 ignore start */
-const computeBrowserLoggingArgs = (args) => {
-  if (args.length === 1 && args[0]?.constructor === Function) {
-    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
-  }
-  const strBuilder = [];
-  const styles = [];
-  const currentStyle = create$9();
-  /**
-   * @type {Array<string|Object|number>}
-   */
-  let logArgs = [];
-  // try with formatting until we find something unsupported
-  let i = 0;
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    // @ts-ignore
-    const style = _browserStyleMap[arg];
-    if (style !== undefined) {
-      currentStyle.set(style.left, style.right);
-    } else {
-      if (arg === undefined) {
-        break
-      }
-      if (arg.constructor === String || arg.constructor === Number) {
-        const style = mapToStyleString(currentStyle);
-        if (i > 0 || style.length > 0) {
-          strBuilder.push('%c' + arg);
-          styles.push(style);
-        } else {
-          strBuilder.push(arg);
-        }
-      } else {
-        break
-      }
-    }
-  }
-  if (i > 0) {
-    // create logArgs with what we have so far
-    logArgs = styles;
-    logArgs.unshift(strBuilder.join(''));
-  }
-  // append the rest
-  for (; i < args.length; i++) {
-    const arg = args[i];
-    if (!(arg instanceof Symbol)) {
-      logArgs.push(arg);
-    }
-  }
-  return logArgs
-};
-/* c8 ignore stop */
-
-/* c8 ignore start */
-const computeLoggingArgs = supportsColor
-  ? computeBrowserLoggingArgs
-  : computeNoColorLoggingArgs;
-/* c8 ignore stop */
 
 /**
- * @param {Array<string|Symbol|Object|number>} args
+ * @template T
+ * @typedef {T extends Schema<infer X> ? X : T} Unwrap
  */
-const print = (...args) => {
-  console.log(...computeLoggingArgs(args));
-  /* c8 ignore next */
-  vconsoles.forEach((vc) => vc.print(args));
-};
 
-/* c8 ignore start */
 /**
- * @param {Array<string|Symbol|Object|number>} args
+ * @template T
+ * @typedef {T extends Schema<infer X> ? X : T} TypeOf
  */
-const warn = (...args) => {
-  console.warn(...computeLoggingArgs(args));
-  args.unshift(ORANGE);
-  vconsoles.forEach((vc) => vc.print(args));
-};
-
-const vconsoles = create$8();
+
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [] } UnwrapArray
+ */
+
+/**
+ * @template T
+ * @typedef {T extends Schema<infer S> ? Schema<S> : never} CastToSchema
+ */
+
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...unknown[], infer L] ? L : never} TupleLast
+ */
+
+/**
+ * @template {unknown[]} Arr
+ * @typedef {Arr extends [...infer Fs, unknown] ? Fs : never} TuplePop
+ */
+
+/**
+ * @template {readonly unknown[]} T
+ * @typedef {T extends []
+ *   ? {}
+ *   : T extends [infer First]
+ *   ? First
+ *   : T extends [infer First, ...infer Rest]
+ *   ? First & Intersect<Rest>
+ *   : never
+ * } Intersect
+ */
+
+const schemaSymbol = Symbol('0schema');
+
+class ValidationError {
+  constructor () {
+    /**
+     * Reverse errors
+     * @type {Array<{ path: string?, expected: string, has: string, message: string? }>}
+     */
+    this._rerrs = [];
+  }
+
+  /**
+   * @param {string?} path
+   * @param {string} expected
+   * @param {string} has
+   * @param {string?} message
+   */
+  extend (path, expected, has, message = null) {
+    this._rerrs.push({ path, expected, has, message });
+  }
+
+  toString () {
+    const s = [];
+    for (let i = this._rerrs.length - 1; i > 0; i--) {
+      const r = this._rerrs[i];
+      /* c8 ignore next */
+      s.push(repeat(' ', (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ''}${r.has} doesn't match ${r.expected}. ${r.message}`);
+    }
+    return s.join('\n')
+  }
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean}
+ */
+const shapeExtends = (a, b) => {
+  if (a === b) return true
+  if (a == null || b == null || a.constructor !== b.constructor) return false
+  if (a[EqualityTraitSymbol]) return equals(a, b) // last resort: check equality (do this before array and obj check which don't implement the equality trait)
+  if (isArray(a)) {
+    return every$1(a, aitem =>
+      some(b, bitem => shapeExtends(aitem, bitem))
+    )
+  } else if (isObject(a)) {
+    return every(a, (aitem, akey) =>
+      shapeExtends(aitem, b[akey])
+    )
+  }
+  /* c8 ignore next */
+  return false
+};
+
+/**
+ * @template T
+ * @implements {equalityTraits.EqualityTrait}
+ */
+class Schema {
+  // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
+  /**
+   * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+   * union). By default, the more objects are added, the the fewer objects this schema will accept.
+   * @protected
+   */
+  static _dilutes = false
+
+  /**
+   * @param {Schema<any>} other
+   */
+  extends (other) {
+    let [a, b] = [/** @type {any} */(this).shape, /** @type {any} */ (other).shape];
+    if (/** @type {typeof Schema<any>} */ (this.constructor)._dilutes) [b, a] = [a, b];
+    return shapeExtends(a, b)
+  }
+
+  /**
+   * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+   * should have.
+   * @param {Schema<any>} other
+   */
+  equals (other) {
+    // @ts-ignore
+    return this.constructor === other.constructor && equalityDeep$1(this.shape, other.shape)
+  }
+
+  [schemaSymbol] () { return true }
+
+  /**
+   * @param {object} other
+   */
+  [EqualityTraitSymbol] (other) {
+    return this.equals(/** @type {any} */ (other))
+  }
+
+  /**
+   * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
+   * Schema. Validate will check the structure of the parameter and return true iff the instance
+   * really is an instance of Schema.
+   *
+   * @param {T} o
+   * @return {boolean}
+   */
+  validate (o) {
+    return this.check(o)
+  }
+
+  /* c8 ignore start */
+  /**
+   * Similar to validate, but this method accepts untyped parameters.
+   *
+   * @param {any} _o
+   * @param {ValidationError} [_err]
+   * @return {_o is T}
+   */
+  check (_o, _err) {
+    methodUnimplemented();
+  }
+  /* c8 ignore stop */
+
+  /**
+   * @type {Schema<T?>}
+   */
+  get nullable () {
+    // @ts-ignore
+    return $union(this, $null)
+  }
+
+  /**
+   * @type {$Optional<Schema<T>>}
+   */
+  get optional () {
+    return new $Optional(/** @type {Schema<T>} */ (this))
+  }
+
+  /**
+   * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check only if not in a production environment.
+   *
+   * @template OO
+   * @param {OO} o
+   * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
+   */
+  cast (o) {
+    assert(o, this);
+    return /** @type {any} */ (o)
+  }
+
+  /**
+   * EXPECTO PATRONUM!! 🪄
+   * This function protects against type errors. Though it may not work in the real world.
+   *
+   * "After all this time?"
+   * "Always." - Snape, talking about type safety
+   *
+   * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
+   * Use this if you know that the type is of a specific type and you just want to convince the type
+   * system.
+   *
+   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
+   *
+   * **Do not rely on these error messages!**
+   * Performs an assertion check if not in a production environment.
+   *
+   * @param {T} o
+   * @return {o extends T ? T : never}
+   */
+  expect (o) {
+    assert(o, this);
+    return o
+  }
+}
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
+ * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
+ */
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
+ * @extends {Schema<Instance<C>>}
+ */
+class $ConstructedBy extends Schema {
+  /**
+   * @param {C} c
+   * @param {((o:Instance<C>)=>boolean)|null} check
+   */
+  constructor (c, check) {
+    super();
+    this.shape = c;
+    this._c = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
+   */
+  check (o, err = undefined) {
+    const c = o?.constructor === this.shape && (this._c == null || this._c(o));
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? 'Constructor match failed' : 'Check failed');
+    return c
+  }
+}
+
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
+ * @param {C} c
+ * @param {((o:Instance<C>) => boolean)|null} check
+ * @return {CastToSchema<$ConstructedBy<C>>}
+ */
+const $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+$constructedBy($ConstructedBy);
+
+/**
+ * Check custom properties on any object. You may want to overwrite the generated Schema<any>.
+ *
+ * @extends {Schema<any>}
+ */
+class $Custom extends Schema {
+  /**
+   * @param {(o:any) => boolean} check
+   */
+  constructor (check) {
+    super();
+    /**
+     * @type {(o:any) => boolean}
+     */
+    this.shape = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check (o, err) {
+    const c = this.shape(o);
+    /* c8 ignore next */
+    !c && err?.extend(null, 'custom prop', o?.constructor.name, 'failed to check custom prop');
+    return c
+  }
+}
+
+/**
+ * @param {(o:any) => boolean} check
+ * @return {Schema<any>}
+ */
+const $custom = (check) => new $Custom(check);
+$constructedBy($Custom);
+
+/**
+ * @template {Primitive} T
+ * @extends {Schema<T>}
+ */
+class $Literal extends Schema {
+  /**
+   * @param {Array<T>} literals
+   */
+  constructor (literals) {
+    super();
+    this.shape = literals;
+  }
+
+  /**
+   *
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is T}
+   */
+  check (o, err) {
+    const c = this.shape.some(a => a === o);
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.join(' | '), o.toString());
+    return c
+  }
+}
+
+/**
+ * @template {Primitive[]} T
+ * @param {T} literals
+ * @return {CastToSchema<$Literal<T[number]>>}
+ */
+const $literal = (...literals) => new $Literal(literals);
+const $$literal = $constructedBy($Literal);
+
+/**
+ * @template {Array<string|Schema<string|number>>} Ts
+ * @typedef {Ts extends [] ? `` : (Ts extends [infer T] ? (Unwrap<T> extends (string|number) ? Unwrap<T> : never) : (Ts extends [infer T1, ...infer Rest] ? `${Unwrap<T1> extends (string|number) ? Unwrap<T1> : never}${Rest extends Array<string|Schema<string|number>> ? CastStringTemplateArgsToTemplate<Rest> : never}` : never))} CastStringTemplateArgsToTemplate
+ */
+
+/**
+ * @param {string} str
+ * @return {string}
+ */
+const _regexEscape = /** @type {any} */ (RegExp).escape || /** @type {(str:string) => string} */ (str =>
+  str.replace(/[().|&,$^[\]]/g, s => '\\' + s)
+);
+
+/**
+ * @param {string|Schema<any>} s
+ * @return {string[]}
+ */
+const _schemaStringTemplateToRegex = s => {
+  if ($string.check(s)) {
+    return [_regexEscape(s)]
+  }
+  if ($$literal.check(s)) {
+    return /** @type {Array<string|number>} */ (s.shape).map(v => v + '')
+  }
+  if ($$number.check(s)) {
+    return ['[+-]?\\d+.?\\d*']
+  }
+  if ($$string.check(s)) {
+    return ['.*']
+  }
+  if ($$union.check(s)) {
+    return s.shape.map(_schemaStringTemplateToRegex).flat(1)
+  }
+  /* c8 ignore next 2 */
+  // unexpected schema structure (only supports unions and string in literal types)
+  unexpectedCase();
+};
+
+/**
+ * @template {Array<string|Schema<string|number>>} T
+ * @extends {Schema<CastStringTemplateArgsToTemplate<T>>}
+ */
+class $StringTemplate extends Schema {
+  /**
+   * @param {T} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+    this._r = new RegExp('^' + shape.map(_schemaStringTemplateToRegex).map(opts => `(${opts.join('|')})`).join('') + '$');
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is CastStringTemplateArgsToTemplate<T>}
+   */
+  check (o, err) {
+    const c = this._r.exec(o) != null;
+    /* c8 ignore next */
+    !c && err?.extend(null, this._r.toString(), o.toString(), 'String doesn\'t match string template.');
+    return c
+  }
+}
+$constructedBy($StringTemplate);
+
+const isOptionalSymbol = Symbol('optional');
+/**
+ * @template {Schema<any>} S
+ * @extends Schema<Unwrap<S>|undefined>
+ */
+class $Optional extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is (Unwrap<S>|undefined)}
+   */
+  check (o, err) {
+    const c = o === undefined || this.shape.check(o);
+    /* c8 ignore next */
+    !c && err?.extend(null, 'undefined (optional)', '()');
+    return c
+  }
+
+  get [isOptionalSymbol] () { return true }
+}
+const $$optional = $constructedBy($Optional);
+
+/**
+ * @extends Schema<never>
+ */
+class $Never extends Schema {
+  /**
+   * @param {any} _o
+   * @param {ValidationError} [err]
+   * @return {_o is never}
+   */
+  check (_o, err) {
+    /* c8 ignore next */
+    err?.extend(null, 'never', typeof _o);
+    return false
+  }
+}
+$constructedBy($Never);
+
+/**
+ * @template {{ [key: string|symbol|number]: Schema<any> }} S
+ * @typedef {{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }} $ObjectToType
+ */
+
+/**
+ * @template {{[key:string|symbol|number]: Schema<any>}} S
+ * @extends {Schema<$ObjectToType<S>>}
+ */
+class $Object extends Schema {
+  /**
+   * @param {S} shape
+   * @param {boolean} partial
+   */
+  constructor (shape, partial = false) {
+    super();
+    /**
+     * @type {S}
+     */
+    this.shape = shape;
+    this._isPartial = partial;
+  }
+
+  static _dilutes = true
+
+  /**
+   * @type {Schema<Partial<$ObjectToType<S>>>}
+   */
+  get partial () {
+    return new $Object(this.shape, true)
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is $ObjectToType<S>}
+   */
+  check (o, err) {
+    if (o == null) {
+      /* c8 ignore next */
+      err?.extend(null, 'object', 'null');
+      return false
+    }
+    return every(this.shape, (vv, vk) => {
+      const c = (this._isPartial && !hasProperty$1(o, vk)) || vv.check(o[vk], err);
+      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], 'Object property does not match');
+      return c
+    })
+  }
+}
+
+/**
+ * @template S
+ * @typedef {Schema<{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }>} _ObjectDefToSchema
+ */
+
+// I used an explicit type annotation instead of $ObjectToType, so that the user doesn't see the
+// weird type definitions when inspecting type definions.
+/**
+ * @template {{ [key:string|symbol|number]: Schema<any> }} S
+ * @param {S} def
+ * @return {_ObjectDefToSchema<S> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never}
+ */
+const $object = def => /** @type {any} */ (new $Object(def));
+const $$object = $constructedBy($Object);
+/**
+ * @type {Schema<{[key:string]: any}>}
+ */
+const $objectAny = $custom(o => o != null && (o.constructor === Object || o.constructor == null));
+
+/**
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @extends {Schema<{ [key in Unwrap<Keys>]: Unwrap<Values> }>}
+ */
+class $Record extends Schema {
+  /**
+   * @param {Keys} keys
+   * @param {Values} values
+   */
+  constructor (keys, values) {
+    super();
+    this.shape = {
+      keys, values
+    };
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
+   */
+  check (o, err) {
+    return o != null && every(o, (vv, vk) => {
+      const ck = this.shape.keys.check(vk, err);
+      /* c8 ignore next */
+      !ck && err?.extend(vk + '', 'Record', typeof o, ck ? 'Key doesn\'t match schema' : 'Value doesn\'t match value');
+      return ck && this.shape.values.check(vv, err)
+    })
+  }
+}
+
+/**
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @param {Keys} keys
+ * @param {Values} values
+ * @return {CastToSchema<$Record<Keys,Values>>}
+ */
+const $record = (keys, values) => new $Record(keys, values);
+const $$record = $constructedBy($Record);
+
+/**
+ * @template {Schema<any>[]} S
+ * @extends {Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never }>}
+ */
+class $Tuple extends Schema {
+  /**
+   * @param {S} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
+   */
+  check (o, err) {
+    return o != null && every(this.shape, (vv, vk) => {
+      const c = /** @type {Schema<any>} */ (vv).check(o[vk], err);
+      /* c8 ignore next */
+      !c && err?.extend(vk.toString(), 'Tuple', typeof vv);
+      return c
+    })
+  }
+}
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @param {T} def
+ * @return {CastToSchema<$Tuple<T>>}
+ */
+const $tuple = (...def) => new $Tuple(def);
+$constructedBy($Tuple);
+
+/**
+ * @template {Schema<any>} S
+ * @extends {Schema<Array<S extends Schema<infer T> ? T : never>>}
+ */
+class $Array extends Schema {
+  /**
+   * @param {Array<S>} v
+   */
+  constructor (v) {
+    super();
+    /**
+     * @type {Schema<S extends Schema<infer T> ? T : never>}
+     */
+    this.shape = v.length === 1 ? v[0] : new $Union(v);
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Array<S extends Schema<infer T> ? T : never>} o
+   */
+  check (o, err) {
+    const c = isArray(o) && every$1(o, oi => this.shape.check(oi));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Array', '');
+    return c
+  }
+}
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @param {T} def
+ * @return {Schema<Array<T extends Array<Schema<infer S>> ? S : never>>}
+ */
+const $array = (...def) => new $Array(def);
+const $$array = $constructedBy($Array);
+/**
+ * @type {Schema<Array<any>>}
+ */
+const $arrayAny = $custom(o => isArray(o));
+
+/**
+ * @template T
+ * @extends {Schema<T>}
+ */
+class $InstanceOf extends Schema {
+  /**
+   * @param {new (...args:any) => T} constructor
+   * @param {((o:T) => boolean)|null} check
+   */
+  constructor (constructor, check) {
+    super();
+    this.shape = constructor;
+    this._c = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is T}
+   */
+  check (o, err) {
+    const c = o instanceof this.shape && (this._c == null || this._c(o));
+    /* c8 ignore next */
+    !c && err?.extend(null, this.shape.name, o?.constructor.name);
+    return c
+  }
+}
+
+/**
+ * @template T
+ * @param {new (...args:any) => T} c
+ * @param {((o:T) => boolean)|null} check
+ * @return {Schema<T>}
+ */
+const $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+$constructedBy($InstanceOf);
+
+const $$schema = $instanceOf(Schema);
+
+/**
+ * @template {Schema<any>[]} Args
+ * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
+ */
+
+/**
+ * @template {Array<Schema<any>>} Args
+ * @extends {Schema<_LArgsToLambdaDef<Args>>}
+ */
+class $Lambda extends Schema {
+  /**
+   * @param {Args} args
+   */
+  constructor (args) {
+    super();
+    this.len = args.length - 1;
+    this.args = $tuple(...args.slice(-1));
+    this.res = args[this.len];
+  }
+
+  /**
+   * @param {any} f
+   * @param {ValidationError} err
+   * @return {f is _LArgsToLambdaDef<Args>}
+   */
+  check (f, err) {
+    const c = f.constructor === Function && f.length <= this.len;
+    /* c8 ignore next */
+    !c && err?.extend(null, 'function', typeof f);
+    return c
+  }
+}
+const $$lambda = $constructedBy($Lambda);
+
+/**
+ * @type {Schema<Function>}
+ */
+const $function = $custom(o => typeof o === 'function');
+
+/**
+ * @template {Array<Schema<any>>} T
+ * @extends {Schema<Intersect<UnwrapArray<T>>>}
+ */
+class $Intersection extends Schema {
+  /**
+   * @param {T} v
+   */
+  constructor (v) {
+    super();
+    /**
+     * @type {T}
+     */
+    this.shape = v;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is Intersect<UnwrapArray<T>>}
+   */
+  check (o, err) {
+    // @ts-ignore
+    const c = every$1(this.shape, check => check.check(o, err));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Intersectinon', typeof o);
+    return c
+  }
+}
+$constructedBy($Intersection, o => o.shape.length > 0); // Intersection with length=0 is considered "any"
+
+/**
+ * @template S
+ * @extends {Schema<S>}
+ */
+class $Union extends Schema {
+  static _dilutes = true
+
+  /**
+   * @param {Array<Schema<S>>} v
+   */
+  constructor (v) {
+    super();
+    this.shape = v;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} [err]
+   * @return {o is S}
+   */
+  check (o, err) {
+    const c = some(this.shape, (vv) => vv.check(o, err));
+    err?.extend(null, 'Union', typeof o);
+    return c
+  }
+}
+
+/**
+ * @template {Array<any>} T
+ * @param {T} schemas
+ * @return {CastToSchema<$Union<Unwrap<ReadSchema<T>>>>}
+ */
+const $union = (...schemas) => schemas.findIndex($s => $$union.check($s)) >= 0
+  ? $union(...schemas.map($s => $($s)).map($s => $$union.check($s) ? $s.shape : [$s]).flat(1))
+  : (schemas.length === 1
+      ? schemas[0]
+      : new $Union(schemas));
+const $$union = /** @type {Schema<$Union<any>>} */ ($constructedBy($Union));
+
+const _t = () => true;
+/**
+ * @type {Schema<any>}
+ */
+const $any = $custom(_t);
+const $$any = /** @type {Schema<Schema<any>>} */ ($constructedBy($Custom, o => o.shape === _t));
+
+/**
+ * @type {Schema<bigint>}
+ */
+const $bigint = $custom(o => typeof o === 'bigint');
+const $$bigint = /** @type {Schema<Schema<BigInt>>} */ ($custom(o => o === $bigint));
+
+/**
+ * @type {Schema<symbol>}
+ */
+const $symbol = $custom(o => typeof o === 'symbol');
+/** @type {Schema<Schema<Symbol>>} */ ($custom(o => o === $symbol));
+
+/**
+ * @type {Schema<number>}
+ */
+const $number = $custom(o => typeof o === 'number');
+const $$number = /** @type {Schema<Schema<number>>} */ ($custom(o => o === $number));
+
+/**
+ * @type {Schema<string>}
+ */
+const $string = $custom(o => typeof o === 'string');
+const $$string = /** @type {Schema<Schema<string>>} */ ($custom(o => o === $string));
+
+/**
+ * @type {Schema<boolean>}
+ */
+const $boolean = $custom(o => typeof o === 'boolean');
+const $$boolean = /** @type {Schema<Schema<Boolean>>} */ ($custom(o => o === $boolean));
+
+/**
+ * @type {Schema<undefined>}
+ */
+const $undefined = $literal(undefined);
+/** @type {Schema<Schema<undefined>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined));
+
+/**
+ * @type {Schema<void>}
+ */
+$literal(undefined);
+
+const $null = $literal(null);
+const $$null = /** @type {Schema<Schema<null>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === null));
+
+$constructedBy(Uint8Array);
+/** @type {Schema<Schema<Uint8Array>>} */ ($constructedBy($ConstructedBy, o => o.shape === Uint8Array));
+
+/**
+ * @type {Schema<Primitive>}
+ */
+const $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
+
+/**
+ * @typedef {JSON[]} JSONArray
+ */
+/**
+ * @typedef {Primitive|JSONArray|{ [key:string]:JSON }} JSON
+ */
+/**
+ * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
+ */
+(() => {
+  const $jsonArr = /** @type {$Array<$any>} */ ($array($any));
+  const $jsonRecord = /** @type {$Record<$string,$any>} */ ($record($string, $any));
+  const $json = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
+  $jsonArr.shape = $json;
+  $jsonRecord.shape.values = $json;
+  return $json
+})();
+
+/**
+ * @template {any} IN
+ * @typedef {IN extends Schema<any> ? IN
+ *   : (IN extends string|number|boolean|null ? Schema<IN>
+ *     : (IN extends new (...args:any[])=>any ? Schema<InstanceType<IN>>
+ *       : (IN extends any[] ? Schema<{ [K in keyof IN]: Unwrap<ReadSchema<IN[K]>> }[number]>
+   *       : (IN extends object ? (_ObjectDefToSchema<{[K in keyof IN]:ReadSchema<IN[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)
+   *         : never)
+ *         )
+ *       )
+ *     )
+ * } ReadSchemaOld
+ */
+
+/**
+ * @template {any} IN
+ * @typedef {[Extract<IN,Schema<any>>,Extract<IN,string|number|boolean|null>,Extract<IN,new (...args:any[])=>any>,Extract<IN,any[]>,Extract<Exclude<IN,Schema<any>|string|number|boolean|null|(new (...args:any[])=>any)|any[]>,object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj]
+ *   ? Schema<
+ *       (Schemas extends Schema<infer S> ? S : never)
+ *     | Primitives
+ *     | (Constructors extends new (...args:any[])=>any ? InstanceType<Constructors> : never)
+ *     | (Arrs extends any[] ? { [K in keyof Arrs]: Unwrap<ReadSchema<Arrs[K]>> }[number] : never)
+ *     | (Obj extends object ? Unwrap<(_ObjectDefToSchema<{[K in keyof Obj]:ReadSchema<Obj[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)> : never)>
+ *   : never
+ * } ReadSchema
+ */
+
+/**
+ * @typedef {ReadSchema<{x:42}|{y:99}|Schema<string>|[1,2,{}]>} Q
+ */
+
+/**
+ * @template IN
+ * @param {IN} o
+ * @return {ReadSchema<IN>}
+ */
+const $ = o => {
+  if ($$schema.check(o)) {
+    return /** @type {any} */ (o)
+  } else if ($objectAny.check(o)) {
+    /**
+     * @type {any}
+     */
+    const o2 = {};
+    for (const k in o) {
+      o2[k] = $(o[k]);
+    }
+    return /** @type {any} */ ($object(o2))
+  } else if ($arrayAny.check(o)) {
+    return /** @type {any} */ ($union(...o.map($)))
+  } else if ($primitive.check(o)) {
+    return /** @type {any} */ ($literal(o))
+  } else if ($function.check(o)) {
+    return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
+  }
+  /* c8 ignore next */
+  unexpectedCase();
+};
+
+/* c8 ignore start */
+/**
+ * Assert that a variable is of this specific type.
+ * The assertion check is only performed in non-production environments.
+ *
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+const assert = production
+  ? () => {}
+  : (o, schema) => {
+      const err = new ValidationError();
+      if (!schema.check(o, err)) {
+        throw create$7(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
+      }
+    };
+/* c8 ignore end */
+
+/**
+ * @template In
+ * @template Out
+ * @typedef {{ if: Schema<In>, h: (o:In,state?:any)=>Out }} Pattern
+ */
+
+/**
+ * @template {Pattern<any,any>} P
+ * @template In
+ * @typedef {ReturnType<Extract<P,Pattern<In extends number ? number : (In extends string ? string : In),any>>['h']>} PatternMatchResult
+ */
+
+/**
+ * @todo move this to separate library
+ * @template {any} [State=undefined]
+ * @template {Pattern<any,any>} [Patterns=never]
+ */
+class PatternMatcher {
+  /**
+   * @param {Schema<State>} [$state]
+   */
+  constructor ($state) {
+    /**
+     * @type {Array<Patterns>}
+     */
+    this.patterns = [];
+    this.$state = $state;
+  }
+
+  /**
+   * @template P
+   * @template R
+   * @param {P} pattern
+   * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
+   * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
+   */
+  if (pattern, handler) {
+    // @ts-ignore
+    this.patterns.push({ if: $(pattern), h: handler });
+    // @ts-ignore
+    return this
+  }
+
+  /**
+   * @template R
+   * @param {(o:any,s:State)=>R} h
+   */
+  else (h) {
+    return this.if($any, h)
+  }
+
+  /**
+   * @return {State extends undefined
+   *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
+   *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
+   */
+  done () {
+    // @ts-ignore
+    return /** @type {any} */ (o, s) => {
+      for (let i = 0; i < this.patterns.length; i++) {
+        const p = this.patterns[i];
+        if (p.if.check(o)) {
+          // @ts-ignore
+          return p.h(o, s)
+        }
+      }
+      throw create$7('Unhandled pattern')
+    }
+  }
+}
+
+/**
+ * @template [State=undefined]
+ * @param {State} [state]
+ * @return {PatternMatcher<State extends undefined ? undefined : Unwrap<ReadSchema<State>>>}
+ */
+const match = state => new PatternMatcher(/** @type {any} */ (state));
+
+/**
+ * Helper function to generate a (non-exhaustive) sample set from a gives schema.
+ *
+ * @type {<T>(o:T,gen:prng.PRNG)=>T}
+ */
+const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any))
+  .if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER$2))
+  .if($$string, (_o, gen) => word(gen))
+  .if($$boolean, (_o, gen) => bool(gen))
+  .if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER$2)))
+  .if($$union, (o, gen) => random(gen, oneOf(gen, o.shape)))
+  .if($$object, (o, gen) => {
+    /**
+     * @type {any}
+     */
+    const res = {};
+    for (const k in o.shape) {
+      let prop = o.shape[k];
+      if ($$optional.check(prop)) {
+        if (bool(gen)) { continue }
+        prop = prop.shape;
+      }
+      res[k] = _random(prop, gen);
+    }
+    return res
+  })
+  .if($$array, (o, gen) => {
+    const arr = [];
+    const n = int32(gen, 0, 42);
+    for (let i = 0; i < n; i++) {
+      arr.push(random(gen, o.shape));
+    }
+    return arr
+  })
+  .if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape)
+  })
+  .if($$null, (o, gen) => {
+    return null
+  })
+  .if($$lambda, (o, gen) => {
+    const res = random(gen, o.res);
+    return () => res
+  })
+  .if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number, $string, $null, $undefined, $bigint, $boolean,
+    $array($number),
+    $record($union('a', 'b', 'c'), $number)
+  ])))
+  .if($$record, (o, gen) => {
+    /**
+     * @type {any}
+     */
+    const res = {};
+    const keysN = int53(gen, 0, 3);
+    for (let i = 0; i < keysN; i++) {
+      const key = random(gen, o.shape.keys);
+      const val = random(gen, o.shape.values);
+      res[key] = val;
+    }
+    return res
+  })
+  .done());
+
+/**
+ * @template S
+ * @param {prng.PRNG} gen
+ * @param {S} schema
+ * @return {Unwrap<ReadSchema<S>>}
+ */
+const random = (gen, schema) => /** @type {any} */ (_random($(schema), gen));
+
+/* 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$1(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 */
+
+/**
+ * Utility module to work with EcmaScript Symbols.
+ *
+ * @module symbol
+ */
+
+/**
+ * Return fresh symbol.
+ */
+const create$4 = Symbol;
+
+const BOLD = create$4();
+const UNBOLD = create$4();
+const BLUE = create$4();
+const GREY = create$4();
+const GREEN = create$4();
+const RED = create$4();
+const PURPLE = create$4();
+const ORANGE = create$4();
+const UNCOLOR = create$4();
+
+/* c8 ignore start */
+/**
+ * @param {Array<undefined|string|Symbol|Object|number|function():any>} args
+ * @return {Array<string|object|number|undefined>}
+ */
+const computeNoColorLoggingArgs = args => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
+  }
+  const strBuilder = [];
+  const logArgs = [];
+  // try with formatting until we find something unsupported
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === undefined) {
+      break
+    } else if (arg.constructor === String || arg.constructor === Number) {
+      strBuilder.push(arg);
+    } else if (arg.constructor === Object) {
+      break
+    }
+  }
+  if (i > 0) {
+    // create logArgs with what we have so far
+    logArgs.push(strBuilder.join(''));
+  }
+  // append the rest
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (!(arg instanceof Symbol)) {
+      logArgs.push(arg);
+    }
+  }
+  return logArgs
+};
+/* c8 ignore stop */
+
+/**
+ * Isomorphic logging module with support for colors!
+ *
+ * @module logging
+ */
+
+
+/**
+ * @type {Object<Symbol,pair.Pair<string,string>>}
+ */
+const _browserStyleMap = {
+  [BOLD]: create$5('font-weight', 'bold'),
+  [UNBOLD]: create$5('font-weight', 'normal'),
+  [BLUE]: create$5('color', 'blue'),
+  [GREEN]: create$5('color', 'green'),
+  [GREY]: create$5('color', 'grey'),
+  [RED]: create$5('color', 'red'),
+  [PURPLE]: create$5('color', 'purple'),
+  [ORANGE]: create$5('color', 'orange'), // not well supported in chrome when debugging node with inspector - TODO: deprecate
+  [UNCOLOR]: create$5('color', 'black')
+};
+
+/**
+ * @param {Array<string|Symbol|Object|number|function():any>} args
+ * @return {Array<string|object|number>}
+ */
+/* c8 ignore start */
+const computeBrowserLoggingArgs = (args) => {
+  if (args.length === 1 && args[0]?.constructor === Function) {
+    args = /** @type {Array<string|Symbol|Object|number>} */ (/** @type {[function]} */ (args)[0]());
+  }
+  const strBuilder = [];
+  const styles = [];
+  const currentStyle = create$9();
+  /**
+   * @type {Array<string|Object|number>}
+   */
+  let logArgs = [];
+  // try with formatting until we find something unsupported
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    // @ts-ignore
+    const style = _browserStyleMap[arg];
+    if (style !== undefined) {
+      currentStyle.set(style.left, style.right);
+    } else {
+      if (arg === undefined) {
+        break
+      }
+      if (arg.constructor === String || arg.constructor === Number) {
+        const style = mapToStyleString(currentStyle);
+        if (i > 0 || style.length > 0) {
+          strBuilder.push('%c' + arg);
+          styles.push(style);
+        } else {
+          strBuilder.push(arg);
+        }
+      } else {
+        break
+      }
+    }
+  }
+  if (i > 0) {
+    // create logArgs with what we have so far
+    logArgs = styles;
+    logArgs.unshift(strBuilder.join(''));
+  }
+  // append the rest
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (!(arg instanceof Symbol)) {
+      logArgs.push(arg);
+    }
+  }
+  return logArgs
+};
+/* c8 ignore stop */
+
+/* c8 ignore start */
+const computeLoggingArgs = supportsColor
+  ? computeBrowserLoggingArgs
+  : computeNoColorLoggingArgs;
+/* c8 ignore stop */
+
+/**
+ * @param {Array<string|Symbol|Object|number>} args
+ */
+const print = (...args) => {
+  console.log(...computeLoggingArgs(args));
+  /* c8 ignore next */
+  vconsoles.forEach((vc) => vc.print(args));
+};
+
+/* c8 ignore start */
+/**
+ * @param {Array<string|Symbol|Object|number>} args
+ */
+const warn = (...args) => {
+  console.warn(...computeLoggingArgs(args));
+  args.unshift(ORANGE);
+  vconsoles.forEach((vc) => vc.print(args));
+};
+
+const vconsoles = create$8();
 
 /**
  * Utility module to create and manipulate Iterators.
@@ -24037,7 +25352,7 @@ class YEvent {
      */
     this._changes = null;
     /**
-     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
      */
     this._keys = null;
     /**
@@ -24080,7 +25395,7 @@ class YEvent {
   }
 
   /**
-   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
+   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
    */
   get keys () {
     if (this._keys === null) {
@@ -27455,12 +28770,10 @@ class YXmlElement extends YXmlFragment {
     const el = new YXmlElement(this.nodeName);
     const attrs = this.getAttributes();
     forEach(attrs, (value, key) => {
-      if (typeof value === 'string') {
-        el.setAttribute(key, value);
-      }
+      el.setAttribute(key, /** @type {any} */ (value));
     });
     // @ts-ignore
-    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item));
+    el.insert(0, this.toArray().map(v => v instanceof AbstractType ? v.clone() : v));
     return el
   }
 
@@ -34365,7 +35678,4 @@ const DEFAULT_LINE_TOOL_CONFIG = {
     },
 };
 
-export { KritzelBaseObject as $, isNode as A, min$2 as B, pow as C, HocuspocusProviderWebsocket as D, KritzelPath as E, KritzelImage as F, KritzelLine as G, HocuspocusProvider as H, KritzelGroup as I, KritzelBrushTool as J, KritzelText as K, KritzelLineTool as L, KritzelEraserTool as M, KritzelImageTool as N, Observable$1 as O, KritzelTextTool as P, KritzelCursorHelper as Q, KritzelSelectionTool as R, IndexedDBSyncProvider as S, KritzelAppStateMap as T, KritzelWorkspace as U, KritzelAnchorManager as V, DEFAULT_BRUSH_CONFIG as W, DEFAULT_TEXT_CONFIG as X, DEFAULT_LINE_TOOL_CONFIG as Y, KritzelDevicesHelper as Z, KritzelMouseButton as _, writeVarUint8Array$2 as a, Schema as a0, schema as a1, addListNodes as a2, EditorView as a3, EditorState as a4, keymap as a5, TextSelection as a6, KritzelKeyboardHelper as a7, KritzelToolRegistry as a8, KritzelGeometryHelper as a9, baseKeymap as aa, KritzelBaseTool as ab, KritzelEventHelper as ac, KritzelIconRegistry as ad, KritzelBaseHandler as ae, KritzelSelectionBox as af, KritzelSelectionGroup as ag, Doc as ah, DEFAULT_SYNC_CONFIG as ai, UndoManager as aj, ObjectHelper as ak, KritzelClassHelper as al, readVarUint8Array$2 as b, applyUpdate as c, encodeStateVector as d, encodeStateAsUpdate as e, createEncoder$1 as f, createDecoder$1 as g, create$8 as h, fromBase64 as i, toBase64 as j, createUint8ArrayFromArrayBuffer as k, offChange as l, readVarString$2 as m, floor$2 as n, onChange as o, getUnixTime$1 as p, equalityDeep$1 as q, readVarUint$2 as r, setIfUndefined$1 as s, toUint8Array$1 as t, writeVarString$2 as u, varStorage as v, writeVarUint$2 as w, map as x, ObservableV2 as y, length$3 as z };
-//# sourceMappingURL=default-line-tool.config-CuBm2vpW.js.map
-
-//# sourceMappingURL=default-line-tool.config-CuBm2vpW.js.map
+export { KritzelBaseObject as $, isNode as A, min$2 as B, pow as C, HocuspocusProviderWebsocket as D, KritzelPath as E, KritzelImage as F, KritzelLine as G, HocuspocusProvider as H, KritzelGroup as I, KritzelBrushTool as J, KritzelText as K, KritzelLineTool as L, KritzelEraserTool as M, KritzelImageTool as N, Observable$1 as O, KritzelTextTool as P, KritzelCursorHelper as Q, KritzelSelectionTool as R, IndexedDBSyncProvider as S, KritzelAppStateMap as T, KritzelWorkspace as U, KritzelAnchorManager as V, DEFAULT_BRUSH_CONFIG as W, DEFAULT_TEXT_CONFIG as X, DEFAULT_LINE_TOOL_CONFIG as Y, KritzelDevicesHelper as Z, KritzelMouseButton as _, writeVarUint8Array$2 as a, Schema$1 as a0, schema as a1, addListNodes as a2, EditorView as a3, EditorState as a4, keymap as a5, TextSelection as a6, KritzelKeyboardHelper as a7, KritzelToolRegistry as a8, KritzelGeometryHelper as a9, baseKeymap as aa, KritzelBaseTool as ab, KritzelEventHelper as ac, KritzelIconRegistry as ad, KritzelBaseHandler as ae, KritzelSelectionBox as af, KritzelSelectionGroup as ag, Doc as ah, DEFAULT_SYNC_CONFIG as ai, UndoManager as aj, ObjectHelper as ak, KritzelClassHelper as al, readVarUint8Array$2 as b, applyUpdate as c, encodeStateVector as d, encodeStateAsUpdate as e, createEncoder$1 as f, createDecoder$1 as g, create$8 as h, fromBase64 as i, toBase64 as j, createUint8ArrayFromArrayBuffer as k, offChange as l, readVarString$2 as m, floor$2 as n, onChange as o, getUnixTime$1 as p, equalityDeep$1 as q, readVarUint$2 as r, setIfUndefined$1 as s, toUint8Array$1 as t, writeVarString$2 as u, varStorage as v, writeVarUint$2 as w, map as x, ObservableV2 as y, length$2 as z };