kritzel-stencil 0.0.172 → 0.1.0

package/dist/cjs/{default-line-tool.config-JuTDR6PF.js → default-line-tool.config-7eJND6Jb.js}

@@ -3030,7 +3030,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).
     */
@@ -3122,7 +3122,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++) {
@@ -3889,7 +3889,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) {
@@ -3925,7 +3925,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");
@@ -3956,7 +3956,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);
@@ -3995,7 +3995,7 @@ function gatherToDOM(obj) {
     }
     return result;
 }
-function doc$1(options) {
+function doc$2(options) {
     return options.document || window.document;
 }
 const suspiciousAttributeCache = new WeakMap();
@@ -7309,7 +7309,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);
@@ -7326,7 +7326,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) {
@@ -7512,17 +7512,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 &&
@@ -10615,7 +10618,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);
@@ -10649,6 +10653,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;
@@ -10876,10 +10887,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));
@@ -10933,7 +10949,7 @@ editHandlers.drop = (view, _event) => {
     }
     view.focus();
     view.dispatch(tr.setMeta("uiEvent", "drop"));
-};
+}
 handlers.focus = view => {
     view.input.lastFocus = Date.now();
     if (!view.focused) {
@@ -11859,6 +11875,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
@@ -13133,7 +13160,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];
 /**
@@ -13961,7 +13988,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,
     });
@@ -18149,6 +18176,12 @@ class KritzelSelectionTool extends KritzelBaseTool {
  * @module map
  */
 
+/**
+ * @template K
+ * @template V
+ * @typedef {Map<K,V>} GlobalMap
+ */
+
 /**
  * Creates a new Map instance.
  *
@@ -18284,6 +18317,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.
  *
@@ -18303,6 +18355,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;
 
 /**
@@ -18492,8 +18558,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;
 
@@ -18533,6 +18601,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);
@@ -18570,7 +18639,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));
@@ -18587,7 +18656,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);
 
@@ -18612,6 +18681,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.
  *
@@ -18668,7 +18743,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;
@@ -18681,10 +18756,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];
@@ -18922,6 +18997,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.
  *
@@ -18957,7 +19040,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) {
@@ -19311,16 +19394,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;
     /**
@@ -19334,8 +19418,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);
 
@@ -19353,9 +19438,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);
@@ -19370,8 +19456,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));
 
@@ -19859,12 +19946,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
@@ -19903,13 +20016,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}
@@ -19956,7 +20062,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
@@ -19982,12 +20088,6 @@ const deepFreeze = (o) => {
   return freeze(o)
 };
 
-const EqualityTraitSymbol = Symbol('Equality');
-
-/**
- * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
- */
-
 /**
  * Common functions and function call helpers.
  *
@@ -20032,7 +20132,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) {
@@ -20076,8 +20176,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) {
@@ -20199,7 +20300,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 &&
@@ -20277,7 +20378,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
@@ -20344,182 +20445,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.
@@ -24039,7 +25354,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;
     /**
@@ -24082,7 +25397,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) {
@@ -27457,12 +28772,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
   }
 
@@ -34407,7 +35720,7 @@ exports.KritzelWorkspace = KritzelWorkspace;
 exports.ObjectHelper = ObjectHelper;
 exports.Observable = Observable$1;
 exports.ObservableV2 = ObservableV2;
-exports.Schema = Schema;
+exports.Schema = Schema$1;
 exports.TextSelection = TextSelection;
 exports.UndoManager = UndoManager;
 exports.addListNodes = addListNodes;
@@ -34425,7 +35738,7 @@ exports.fromBase64 = fromBase64;
 exports.getUnixTime = getUnixTime$1;
 exports.isNode = isNode;
 exports.keymap = keymap;
-exports.length = length$3;
+exports.length = length$2;
 exports.map = map;
 exports.min = min$2;
 exports.offChange = offChange;
@@ -34442,6 +35755,3 @@ exports.varStorage = varStorage;
 exports.writeVarString = writeVarString$2;
 exports.writeVarUint = writeVarUint$2;
 exports.writeVarUint8Array = writeVarUint8Array$2;
-//# sourceMappingURL=default-line-tool.config-JuTDR6PF.js.map
-
-//# sourceMappingURL=default-line-tool.config-JuTDR6PF.js.map