@kokimoki/app 3.1.3 → 3.1.4

package/dist/kokimoki.min.js

@@ -1,8 +1,5 @@
-import i18next from 'i18next';
-import HttpBackend from 'i18next-http-backend';
 import require$$1 from 'path';
 import require$$2 from 'fs';
-import { useMemo, useRef, useSyncExternalStore, useCallback, useLayoutEffect, useEffect, useDebugValue } from 'react';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -495,12 +492,6 @@ var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
  * @module map
  */
 
-/**
- * @template K
- * @template V
- * @typedef {Map<K,V>} GlobalMap
- */
-
 /**
  * Creates a new Map instance.
  *
@@ -636,58 +627,6 @@ const appendTo = (dest, src) => {
  */
 const from = 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.
- *
- * @function
- * @template {ArrayLike<any>} ARR
- *
- * @param {ARR} arr
- * @param {ARR extends ArrayLike<infer S> ? ((value:S, index:number, arr:ARR) => boolean) : never} f
- * @return {boolean}
- */
-const some = (arr, f) => {
-  for (let i = 0; i < arr.length; i++) {
-    if (f(arr[i], i, arr)) {
-      return true
-    }
-  }
-  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$1 = Array.isArray;
 
 /**
@@ -803,10 +742,8 @@ const min$2 = (a, b) => a < b ? a : b;
 const max$3 = (a, b) => a > b ? a : b;
 
 /**
- * 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 distinguishes between -0 and +0
+ * @return {boolean} Wether n is negative. This function also differentiates between -0 and +0
  */
 const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
 
@@ -846,19 +783,10 @@ const BITS31 = 0x7FFFFFFF;
 
 
 const MAX_SAFE_INTEGER = 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);
 
-/**
- * Utility module to work with strings.
- *
- * @module string
- */
-
-const fromCharCode = String.fromCharCode;
-
 /**
  * @param {string} s
  * @return {string}
@@ -884,7 +812,7 @@ const fromCamelCase = (s, separator) => trimLeft(s.replace(fromCamelCaseRegex, m
 
 /**
  * @param {string} str
- * @return {Uint8Array<ArrayBuffer>}
+ * @return {Uint8Array}
  */
 const _encodeUtf8Polyfill = str => {
   const encodedString = unescape(encodeURIComponent(str));
@@ -901,7 +829,7 @@ const utf8TextEncoder = /** @type {TextEncoder} */ (typeof TextEncoder !== 'unde
 
 /**
  * @param {string} str
- * @return {Uint8Array<ArrayBuffer>}
+ * @return {Uint8Array}
  */
 const _encodeUtf8Native = str => utf8TextEncoder.encode(str);
 
@@ -926,12 +854,6 @@ if (utf8TextDecoder && utf8TextDecoder.decode(new Uint8Array()).length === 1) {
   utf8TextDecoder = 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.
  *
@@ -1001,7 +923,7 @@ const length = encoder => {
  *
  * @function
  * @param {Encoder} encoder
- * @return {Uint8Array<ArrayBuffer>} The created ArrayBuffer.
+ * @return {Uint8Array} The created ArrayBuffer.
  */
 const toUint8Array = encoder => {
   const uint8arr = new Uint8Array(length(encoder));
@@ -1242,14 +1164,6 @@ 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.
  *
@@ -1285,7 +1199,7 @@ const isFloat32 = num => {
  *          lib0/encoding.js
  *
  * @param {Encoder} encoder
- * @param {AnyEncodable} data
+ * @param {undefined|null|number|bigint|boolean|string|Object<string,any>|Array<any>|Uint8Array} data
  */
 const writeAny = (encoder, data) => {
   switch (typeof data) {
@@ -1639,17 +1553,16 @@ const errorIntegerOutOfRange = create$3('Integer out of Range');
 
 /**
  * A Decoder handles the decoding of an Uint8Array.
- * @template {ArrayBufferLike} [Buf=ArrayBufferLike]
  */
 class Decoder {
   /**
-   * @param {Uint8Array<Buf>} uint8Array Binary data to decode
+   * @param {Uint8Array} uint8Array Binary data to decode
    */
   constructor (uint8Array) {
     /**
      * Decoding target.
      *
-     * @type {Uint8Array<Buf>}
+     * @type {Uint8Array}
      */
     this.arr = uint8Array;
     /**
@@ -1663,9 +1576,8 @@ class Decoder {
 
 /**
  * @function
- * @template {ArrayBufferLike} Buf
- * @param {Uint8Array<Buf>} uint8Array
- * @return {Decoder<Buf>}
+ * @param {Uint8Array} uint8Array
+ * @return {Decoder}
  */
 const createDecoder = uint8Array => new Decoder(uint8Array);
 
@@ -1683,10 +1595,9 @@ const hasContent = decoder => decoder.pos !== decoder.arr.length;
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @template {ArrayBufferLike} Buf
- * @param {Decoder<Buf>} decoder The decoder instance
+ * @param {Decoder} decoder The decoder instance
  * @param {number} len The length of bytes to read
- * @return {Uint8Array<Buf>}
+ * @return {Uint8Array}
  */
 const readUint8Array = (decoder, len) => {
   const view = new Uint8Array(decoder.arr.buffer, decoder.pos + decoder.arr.byteOffset, len);
@@ -1701,9 +1612,8 @@ const readUint8Array = (decoder, len) => {
  *            Use `buffer.copyUint8Array` to copy the result into a new Uint8Array.
  *
  * @function
- * @template {ArrayBufferLike} Buf
- * @param {Decoder<Buf>} decoder
- * @return {Uint8Array<Buf>}
+ * @param {Decoder} decoder
+ * @return {Uint8Array}
  */
 const readVarUint8Array = decoder => readUint8Array(decoder, readVarUint(decoder));
 
@@ -2159,43 +2069,17 @@ try {
 /* c8 ignore next */
 const varStorage = _localStorage;
 
-const EqualityTraitSymbol = Symbol('Equality');
-
 /**
- * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait
- */
-
-/**
- *
- * Utility function to compare any two objects.
+ * Utility functions for working with EcmaScript 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}
+ * @module object
  */
-const equals = (a, b) => a === b || !!a?.[EqualityTraitSymbol]?.(b) || false;
 
-/**
- * @param {any} o
- * @return {o is { [k:string]:any }}
- */
-const isObject$2 = o => typeof o === 'object';
 
 /**
  * Object.assign
  */
-const assign = Object.assign;
+const assign$1 = Object.assign;
 
 /**
  * @param {Object<string,any>} obj
@@ -2259,7 +2143,7 @@ const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
  * @param {Object<string,any>} b
  * @return {boolean}
  */
-const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && equals(b[key], val)));
+const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && b[key] === val));
 
 /**
  * Make an object immutable. This hurts performance and is usually not needed if you perform good
@@ -2318,88 +2202,6 @@ const callAll = (fs, args, i = 0) => {
  */
 const id = a => a;
 
-/* c8 ignore start */
-
-/**
- * @param {any} a
- * @param {any} b
- * @return {boolean}
- */
-const equalityDeep = (a, b) => {
-  if (a === b) {
-    return true
-  }
-  if (a == null || b == null || (a.constructor !== b.constructor && (a.constructor || Object) !== (b.constructor || Object))) {
-    return false
-  }
-  if (a[EqualityTraitSymbol] != null) {
-    return a[EqualityTraitSymbol](b)
-  }
-  switch (a.constructor) {
-    case ArrayBuffer:
-      a = new Uint8Array(a);
-      b = new Uint8Array(b);
-    // eslint-disable-next-line no-fallthrough
-    case Uint8Array: {
-      if (a.byteLength !== b.byteLength) {
-        return false
-      }
-      for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) {
-          return false
-        }
-      }
-      break
-    }
-    case Set: {
-      if (a.size !== b.size) {
-        return false
-      }
-      for (const value of a) {
-        if (!b.has(value)) {
-          return false
-        }
-      }
-      break
-    }
-    case Map: {
-      if (a.size !== b.size) {
-        return false
-      }
-      for (const key of a.keys()) {
-        if (!b.has(key) || !equalityDeep(a.get(key), b.get(key))) {
-          return false
-        }
-      }
-      break
-    }
-    case undefined:
-    case Object:
-      if (size(a) !== size(b)) {
-        return false
-      }
-      for (const key in a) {
-        if (!hasProperty(a, key) || !equalityDeep(a[key], b[key])) {
-          return false
-        }
-      }
-      break
-    case Array:
-      if (a.length !== b.length) {
-        return false
-      }
-      for (let i = 0; i < a.length; i++) {
-        if (!equalityDeep(a[i], b[i])) {
-          return false
-        }
-      }
-      break
-    default:
-      return false
-  }
-  return true
-};
-
 /**
  * @template V
  * @template {V} OPTS
@@ -2494,7 +2296,7 @@ const hasConf = (name) =>
   hasParam('--' + name) || getVariable(name) !== null;
 
 /* c8 ignore next */
-const production = hasConf('production');
+hasConf('production');
 
 /* c8 ignore next 2 */
 const forceColor = isNode &&
@@ -2517,1285 +2319,71 @@ const supportsColor = forceColor || (
     getVariable('COLORTERM') !== null ||
     (getVariable('TERM') || '').includes('color')
   )
-);
-/* c8 ignore stop */
-
-/**
- * Utility functions to work with buffers (Uint8Array).
- *
- * @module buffer
- */
-
-
-/**
- * @param {number} len
- */
-const createUint8ArrayFromLen = len => new Uint8Array(len);
-
-/**
- * Copy the content of an Uint8Array view to a new ArrayBuffer.
- *
- * @param {Uint8Array} uint8Array
- * @return {Uint8Array}
- */
-const copyUint8Array = uint8Array => {
-  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
-  newBuf.set(uint8Array);
-  return newBuf
-};
-
-/**
- * Working with value pairs.
- *
- * @module pair
- */
-
-/**
- * @template L,R
- */
-class Pair {
-  /**
-   * @param {L} left
-   * @param {R} right
-   */
-  constructor (left, right) {
-    this.left = left;
-    this.right = right;
-  }
-}
-
-/**
- * @template L,R
- * @param {L} left
- * @param {R} right
- * @return {Pair<L,R>}
- */
-const create$1 = (left, right) => new Pair(left, right);
-
-/**
- * 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
- */
-
-
-/**
- * Generates a single random bool.
- *
- * @param {PRNG} gen A random number generator.
- * @return {Boolean} A random boolean
- */
-const bool = gen => (gen.next() >= 0.5);
-
-/**
- * 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 int53 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
-
-/**
- * Generates a random integer with 32 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 int32 = (gen, min, max) => floor$2(gen.next() * (max + 1 - min) + min);
-
-/**
- * @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 int31 = (gen, min, max) => int32(gen, min, max);
-
-/**
- * @param {PRNG} gen
- * @return {string} A single letter (a-z)
- */
-const letter = gen => fromCharCode(int31(gen, 97, 122));
-
-/**
- * @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 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 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 */
-
-/**
- * @experimental WIP
- *
- * Simple & efficient schemas for your data.
- */
-
-
-/**
- * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
- */
-
-/**
- * @typedef {{ [k:string|number|symbol]: any }} AnyObject
- */
-
-/**
- * @template T
- * @typedef {T extends Schema<infer X> ? X : T} Unwrap
- */
-
-/**
- * @template T
- * @typedef {T extends Schema<infer X> ? X : T} TypeOf
- */
-
-/**
- * @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$1(a)) {
-    return every$1(a, aitem =>
-      some(b, bitem => shapeExtends(aitem, bitem))
-    )
-  } else if (isObject$2(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(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>>}
- */
-let $Object$3 = 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(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$3(def));
-const $$object = $constructedBy($Object$3);
-/**
- * @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$1(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$1(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$3(`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$3('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))
-  .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)))
-  .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());
+);
+/* c8 ignore stop */
 
 /**
- * @template S
- * @param {prng.PRNG} gen
- * @param {S} schema
- * @return {Unwrap<ReadSchema<S>>}
+ * Utility functions to work with buffers (Uint8Array).
+ *
+ * @module buffer
  */
-const random = (gen, schema) => /** @type {any} */ (_random($(schema), gen));
-
-/* eslint-env browser */
 
 
-/* c8 ignore start */
 /**
- * @type {Document}
+ * @param {number} len
  */
-const doc = /** @type {Document} */ (typeof document !== 'undefined' ? document : {});
+const createUint8ArrayFromLen = len => new Uint8Array(len);
 
 /**
- * @type {$.Schema<DocumentFragment>}
+ * Copy the content of an Uint8Array view to a new ArrayBuffer.
+ *
+ * @param {Uint8Array} uint8Array
+ * @return {Uint8Array}
  */
-$custom(el => el.nodeType === DOCUMENT_FRAGMENT_NODE);
-
-/** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
+const copyUint8Array = uint8Array => {
+  const newBuf = createUint8ArrayFromLen(uint8Array.byteLength);
+  newBuf.set(uint8Array);
+  return newBuf
+};
 
 /**
- * @type {$.Schema<Element>}
+ * Working with value pairs.
+ *
+ * @module pair
  */
-$custom(el => el.nodeType === ELEMENT_NODE);
 
 /**
- * @type {$.Schema<Text>}
+ * @template L,R
  */
-$custom(el => el.nodeType === TEXT_NODE);
+class Pair {
+  /**
+   * @param {L} left
+   * @param {R} right
+   */
+  constructor (left, right) {
+    this.left = left;
+    this.right = right;
+  }
+}
 
 /**
- * @param {Map<string,string>} m
- * @return {string}
+ * @template L,R
+ * @param {L} left
+ * @param {R} right
+ * @return {Pair<L,R>}
  */
-const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join('');
+const create$1 = (left, right) => new Pair(left, right);
+
+/* eslint-env browser */
+
 
-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 {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null);
 
 /**
- * @type {$.Schema<Node>}
+ * @param {Map<string,string>} m
+ * @return {string}
  */
-$custom(el => el.nodeType === DOCUMENT_NODE);
+const mapToStyleString = m => map(m, (value, key) => `${key}:${value};`).join('');
 /* c8 ignore stop */
 
 /**
@@ -6458,21 +5046,17 @@ const cleanupTransactions = (transactionCleanups, i) => {
             // sort events by path length so that top-level events are fired first.
             events
               .sort((event1, event2) => event1.path.length - event2.path.length);
-            fs.push(() => {
-              // We don't need to check for events.length
-              // because we know it has at least one element
-              callEventHandlerListeners(type._dEH, events, transaction);
-            });
-          }
-        });
-        fs.push(() => doc.emit('afterTransaction', [transaction, doc]));
-        fs.push(() => {
-          if (transaction._needFormattingCleanup) {
-            cleanupYTextAfterTransaction(transaction);
+            // We don't need to check for events.length
+            // because we know it has at least one element
+            callEventHandlerListeners(type._dEH, events, transaction);
           }
         });
       });
+      fs.push(() => doc.emit('afterTransaction', [transaction, doc]));
       callAll(fs, []);
+      if (transaction._needFormattingCleanup) {
+        cleanupYTextAfterTransaction(transaction);
+      }
     } finally {
       // Replace deleted items with ItemDeleted / GC.
       // This is where content is actually remove from the Yjs Doc.
@@ -7034,7 +5618,7 @@ class YEvent {
      */
     this._changes = null;
     /**
-     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
+     * @type {null | Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
      */
     this._keys = null;
     /**
@@ -7077,7 +5661,7 @@ class YEvent {
   }
 
   /**
-   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any }>}
+   * @type {Map<string, { action: 'add' | 'update' | 'delete', oldValue: any, newValue: any }>}
    */
   get keys () {
     if (this._keys === null) {
@@ -9354,7 +7938,7 @@ class YTextEvent extends YEvent {
                 if (retain > 0) {
                   op = { retain };
                   if (!isEmpty(attributes)) {
-                    op.attributes = assign({}, attributes);
+                    op.attributes = assign$1({}, attributes);
                   }
                 }
                 retain = 0;
@@ -10452,10 +9036,12 @@ class YXmlElement extends YXmlFragment {
     const el = new YXmlElement(this.nodeName);
     const attrs = this.getAttributes();
     forEach$2(attrs, (value, key) => {
-      el.setAttribute(key, /** @type {any} */ (value));
+      if (typeof value === 'string') {
+        el.setAttribute(key, value);
+      }
     });
     // @ts-ignore
-    el.insert(0, this.toArray().map(v => v instanceof AbstractType ? v.clone() : v));
+    el.insert(0, this.toArray().map(item => item instanceof AbstractType ? item.clone() : item));
     return el
   }
 
@@ -12727,448 +11313,124 @@ class KokimokiAiService {
         this.client = client;
     }
     /**
-     * Generate a chat response from the AI model.
-     *
-     * Sends a chat request to the AI service and returns the generated response.
-     * Supports multiple AI models including GPT and Gemini variants with configurable
-     * parameters for fine-tuning the response behavior.
-     *
-     * @param req The chat request parameters.
-     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
-     *                  Available models:
-     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
-     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
-     *                  - `gpt-5`: OpenAI GPT-5 (latest)
-     *                  - `gpt-5-mini`: Smaller GPT-5 variant
-     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
-     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
-     *                  - `gemini-2.5-flash`: Google Gemini fast variant
-     *                  - `gemini-3-flash-preview`: Google Gemini 3 Flash preview
-     *                  - `gemini-3-pro-preview`: Google Gemini 3 Pro preview
-     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
-     *                         This helps define the AI's role, personality, and constraints.
-     * @param req.userPrompt The user's message or question to send to the AI.
-     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
-     *                        Lower values make output more focused and deterministic,
-     *                        higher values make it more creative and varied.
-     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
-     *                      Controls the length of the AI's output.
-     * @param req.imageUrls Optional. Image URLs to include with the user prompt (Gemini models only).
-     *                      Allows the AI to analyze and respond based on the provided images.
-     *
-     * @returns A promise that resolves to an object containing the AI-generated response.
-     * @returns {string} content The text content of the AI's response.
-     *
-     * @throws An error object if the API request fails.
-     *
-     * @example
-     * ```typescript
-     * const response = await client.ai.chat({
-     *   model: "gpt-4o",
-     *   systemPrompt: "You are a helpful coding assistant.",
-     *   userPrompt: "Explain what TypeScript is in one sentence.",
-     *   temperature: 0.7,
-     *   maxTokens: 100
-     * });
-     * console.log(response.content);
-     * ```
-     */
-    async chat(req) {
-        const res = await fetch(`${this.client.apiUrl}/ai/chat`, {
-            method: "POST",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify(req),
-        });
-        if (!res.ok) {
-            throw await res.json();
-        }
-        return await res.json();
-    }
-    /**
-     * Generate structured JSON output from the AI model.
-     *
-     * Sends a chat request to the AI service with the expectation of receiving
-     * a JSON-formatted response. This is useful for scenarios where the output
-     * needs to be parsed or processed programmatically.
-     *
-     * **Important:** Your prompt must include the word "json" and should describe
-     * the expected output schema (field names, types, and structure) to ensure
-     * the AI generates properly formatted responses.
-     *
-     * @param req The chat request parameters.
-     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
-     *                  Available models:
-     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
-     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
-     *                  - `gpt-5`: OpenAI GPT-5 (latest)
-     *                  - `gpt-5-mini`: Smaller GPT-5 variant
-     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
-     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
-     *                  - `gemini-2.5-flash`: Google Gemini fast variant
-     *                  - `gemini-3-flash-preview`: Google Gemini 3 Flash preview
-     *                  - `gemini-3-pro-preview`: Google Gemini 3 Pro preview
-     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
-     *                         This helps define the AI's role, personality, and constraints.
-     * @param req.userPrompt The user's message or question to send to the AI.
-     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
-     *                        Lower values make output more focused and deterministic,
-     *                        higher values make it more creative and varied.
-     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
-     *                      Controls the length of the AI's output.
-     * @param req.imageUrls Optional. Image URLs to include with the user prompt (Gemini models only).
-     *                      Allows the AI to analyze images and generate structured JSON based on them.
-     *
-     * @returns A promise that resolves to the parsed JSON object generated by the AI.
-     *
-     * @throws An error object if the API request fails or if the response is not valid JSON.
-     */
-    async generateJson(req) {
-        const { content } = await this.chat({
-            ...req,
-            responseMimeType: "application/json",
-        });
-        return JSON.parse(content);
-    }
-    /**
-     * Modify an image using the AI service.
-     * @param baseImageUrl The URL of the base image to modify.
-     * @param prompt The modification prompt to apply to the image.
-     * @param tags Optional. Tags to associate with the image.
-     * @returns A promise that resolves to the modified image upload information.
-     */
-    async modifyImage(baseImageUrl, prompt, tags = [], model = 'gemini-2.5-flash-image') {
-        const res = await fetch(`${this.client.apiUrl}/ai/modify-image`, {
-            method: "POST",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify({ baseImageUrl, prompt, tags, model }),
-        });
-        if (!res.ok) {
-            throw await res.json();
-        }
-        return await res.json();
-    }
-}
-
-let _kmEnv;
-/**
- * Parses and returns the Kokimoki environment configuration.
- *
- * The environment is injected into the HTML by @kokimoki/kit as a JSON script tag
- * with id `kokimoki-env`. In production, placeholder values are replaced by the server.
- *
- * @returns The parsed KokimokiEnv object
- * @throws Error if the kokimoki-env element is not found
- *
- * @example
- * ```typescript
- * import { getKmEnv } from '@kokimoki/app';
- *
- * const env = getKmEnv();
- * console.log(env.dev); // true in development
- * console.log(env.assets); // CDN URL in production
- *
- * // Cast i18n to your app's type if needed
- * const i18n = env.i18n as typeof i18nResources;
- * ```
- */
-function getKmEnv() {
-    if (_kmEnv) {
-        return _kmEnv;
-    }
-    const element = document.getElementById("kokimoki-env");
-    if (!element) {
-        throw new Error("kokimoki-env element not found. Ensure the app is built with @kokimoki/kit.");
-    }
-    _kmEnv = JSON.parse(element.textContent);
-    return _kmEnv;
-}
-
-/**
- * Kokimoki i18n Service
- *
- * Provides translation loading via HTTP backend. Both development and production
- * use HTTP to load translations consistently.
- *
- * In development, translations are served by @kokimoki/kit's dev server middleware.
- * In production, translations are served from the assets CDN.
- *
- * **Key Features:**
- * - Pre-configured i18next instance creation
- * - Consistent HTTP-based loading in dev and prod
- * - URL resolution for translation namespaces
- * - AI-powered translation requests
- *
- * Access via `kmClient.i18n`
- *
- * @example
- * ```typescript
- * // Setup with React
- * import { initReactI18next } from 'react-i18next';
- *
- * export const i18n = kmClient.i18n.createI18n({
- *   use: [initReactI18next]
- * });
- *
- * // Initialize with primary language
- * await kmClient.i18n.init('en');
- *
- * // Request AI translation for another language
- * const result = await kmClient.i18n.requestTranslation('de');
- * // Then poll getTranslationStatus('de') until available
- * ```
- */
-class KokimokiI18nService {
-    client;
-    initPromise = null;
-    instance = null;
-    options = {};
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Create and configure an i18next instance.
-     *
-     * This sets up the instance with plugins but does NOT initialize it.
-     * Call `init(lng)` to initialize with a specific language.
-     *
-     * @param options - Configuration options (plugins, fallback, defaultNS)
-     * @returns Configured i18next instance (not yet initialized)
-     *
-     * @example
-     * ```typescript
-     * // With React
-     * import { initReactI18next } from 'react-i18next';
-     *
-     * export const i18n = kmClient.i18n.createI18n({
-     *   use: [initReactI18next]
-     * });
-     *
-     * // Later, when you know the language:
-     * await kmClient.i18n.init('en');
-     *
-     * // Then in components:
-     * const { t } = useTranslation('game');
-     * ```
-     */
-    createI18n(options) {
-        const env = getKmEnv();
-        const namespaces = env.i18nNamespaces ?? [];
-        if (namespaces.length === 0) {
-            console.warn("[KokimokiI18n] No i18n namespaces found. Make sure i18n is configured in @kokimoki/kit plugin.");
-        }
-        this.options = options ?? {};
-        this.instance = i18next.createInstance();
-        // Apply plugins
-        if (options?.use) {
-            for (const plugin of options.use) {
-                this.instance.use(plugin);
-            }
-        }
-        // Add HTTP backend
-        this.instance.use(HttpBackend);
-        return this.instance;
-    }
-    /**
-     * Initialize the i18next instance with a specific language.
-     *
-     * Must call `createI18n()` first to set up the instance.
-     *
-     * @param lng - The language code to initialize with (e.g., 'en', 'de')
-     * @returns Promise that resolves when i18n is ready
-     *
-     * @example
-     * ```typescript
-     * // Create instance first
-     * const i18n = kmClient.i18n.createI18n({ use: [initReactI18next] });
-     *
-     * // Then initialize when you know the language
-     * await kmClient.i18n.init('en');
-     * ```
-     */
-    async init(lng) {
-        if (!this.instance) {
-            throw new Error("Call createI18n() before init()");
-        }
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        const env = getKmEnv();
-        const namespaces = env.i18nNamespaces ?? [];
-        const fallbackLng = this.options.fallbackLng ?? lng;
-        const defaultNS = this.options.defaultNS;
-        this.initPromise = this.instance.init({
-            lng,
-            fallbackLng,
-            ns: namespaces,
-            defaultNS,
-            backend: {
-                loadPath: (lng, ns) => this.getNamespaceUrl(lng, ns),
-            },
-            interpolation: {
-                escapeValue: false,
-            },
-        });
-        return this.initPromise;
-    }
-    /**
-     * Get the URL for a translation namespace.
-     *
-     * Returns the appropriate URL based on environment:
-     * - Development: `/__kokimoki/i18n/{lng}/{ns}.json`
-     * - Production: `{assets}/km-i18n/{lng}/{ns}.json`
-     *
-     * @param lng - Language code (e.g., 'en', 'et', 'de')
-     * @param ns - Namespace (e.g., 'ui', 'game', 'setup')
-     * @returns Full URL to the translation JSON file
-     *
-     * @example
-     * ```typescript
-     * const url = kmClient.i18n.getNamespaceUrl('en', 'game');
-     * // Dev: "/__kokimoki/i18n/en/game.json"
-     * // Prod: "https://cdn.kokimoki.com/build-123/km-i18n/en/game.json"
-     * ```
-     */
-    getNamespaceUrl(lng, ns) {
-        const env = getKmEnv();
-        if (env.dev) {
-            // Development: use kit plugin's middleware
-            return `/__kokimoki/i18n/${lng}/${ns}.json`;
-        }
-        // Production: use assets CDN with configured i18n path
-        const i18nPath = env.i18nPath ?? 'km-i18n';
-        return `${env.assets}/${i18nPath}/${lng}/${ns}.json`;
-    }
-    /**
-     * Get the list of available namespaces.
-     *
-     * @returns Array of namespace names configured in @kokimoki/kit
-     */
-    getNamespaces() {
-        return getKmEnv().i18nNamespaces ?? [];
-    }
-    /**
-     * Get the list of available languages.
+     * Generate a chat response from the AI model.
      *
-     * @returns Array of language codes configured in @kokimoki/kit
-     */
-    getLanguages() {
-        return getKmEnv().i18nLanguages ?? [];
-    }
-    /**
-     * Get the status of all languages that have been requested for AI translation.
+     * Sends a chat request to the AI service and returns the generated response.
+     * Supports multiple AI models including GPT and Gemini variants with configurable
+     * parameters for fine-tuning the response behavior.
+     *
+     * @param req The chat request parameters.
+     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
+     *                  Available models:
+     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
+     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
+     *                  - `gpt-5`: OpenAI GPT-5 (latest)
+     *                  - `gpt-5-mini`: Smaller GPT-5 variant
+     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
+     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
+     *                  - `gemini-2.5-flash`: Google Gemini fast variant
+     *                  - `gemini-3-flash-preview`: Google Gemini 3 Flash preview
+     *                  - `gemini-3-pro-preview`: Google Gemini 3 Pro preview
+     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
+     *                         This helps define the AI's role, personality, and constraints.
+     * @param req.userPrompt The user's message or question to send to the AI.
+     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
+     *                        Lower values make output more focused and deterministic,
+     *                        higher values make it more creative and varied.
+     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
+     *                      Controls the length of the AI's output.
+     * @param req.imageUrls Optional. Image URLs to include with the user prompt (Gemini models only).
+     *                      Allows the AI to analyze and respond based on the provided images.
      *
-     * Only available in production. In development, returns an empty array.
+     * @returns A promise that resolves to an object containing the AI-generated response.
+     * @returns {string} content The text content of the AI's response.
      *
-     * @returns Promise with array of language statuses
+     * @throws An error object if the API request fails.
      *
      * @example
      * ```typescript
-     * const { languages } = await kmClient.i18n.getAllLanguagesStatus();
-     * // [{ lng: 'de', status: 'available' }, { lng: 'fr', status: 'processing' }]
+     * const response = await client.ai.chat({
+     *   model: "gpt-4o",
+     *   systemPrompt: "You are a helpful coding assistant.",
+     *   userPrompt: "Explain what TypeScript is in one sentence.",
+     *   temperature: 0.7,
+     *   maxTokens: 100
+     * });
+     * console.log(response.content);
      * ```
      */
-    async getAllLanguagesStatus() {
-        const env = getKmEnv();
-        if (env.dev) {
-            return { languages: [] };
-        }
-        const res = await fetch(`${this.client.apiUrl}/i18n`, {
-            method: "GET",
+    async chat(req) {
+        const res = await fetch(`${this.client.apiUrl}/ai/chat`, {
+            method: "POST",
             headers: this.client.apiHeaders,
+            body: JSON.stringify(req),
         });
+        if (!res.ok) {
+            throw await res.json();
+        }
         return await res.json();
     }
     /**
-     * Get the translation status for a specific language.
+     * Generate structured JSON output from the AI model.
      *
-     * Returns the overall status and per-namespace status for the given language.
-     * In development, returns 'available' for local languages and 'not_available' for others.
-     * In production, queries the API for the actual status.
+     * Sends a chat request to the AI service with the expectation of receiving
+     * a JSON-formatted response. This is useful for scenarios where the output
+     * needs to be parsed or processed programmatically.
      *
-     * @param lng - Target language code (e.g., 'de', 'fr', 'es')
-     * @returns Promise with translation status
+     * **Important:** Your prompt must include the word "json" and should describe
+     * the expected output schema (field names, types, and structure) to ensure
+     * the AI generates properly formatted responses.
      *
-     * @example
-     * ```typescript
-     * const status = await kmClient.i18n.getTranslationStatus('de');
-     * if (status.status === 'available') {
-     *   // All translations ready, can switch language
-     *   i18next.changeLanguage('de');
-     * } else if (status.status === 'processing') {
-     *   // Show loading indicator
-     * } else {
-     *   // Request translation
-     *   await kmClient.i18n.requestTranslation('de');
-     * }
-     * ```
+     * @param req The chat request parameters.
+     * @param req.model Optional. The AI model to use. Defaults to server-side default if not specified.
+     *                  Available models:
+     *                  - `gpt-4o`: OpenAI GPT-4 Optimized
+     *                  - `gpt-4o-mini`: Smaller, faster GPT-4 variant
+     *                  - `gpt-5`: OpenAI GPT-5 (latest)
+     *                  - `gpt-5-mini`: Smaller GPT-5 variant
+     *                  - `gpt-5-nano`: Smallest GPT-5 variant for lightweight tasks
+     *                  - `gemini-2.5-flash-lite`: Google Gemini lite variant
+     *                  - `gemini-2.5-flash`: Google Gemini fast variant
+     *                  - `gemini-3-flash-preview`: Google Gemini 3 Flash preview
+     *                  - `gemini-3-pro-preview`: Google Gemini 3 Pro preview
+     * @param req.systemPrompt Optional. The system message that sets the behavior and context for the AI.
+     *                         This helps define the AI's role, personality, and constraints.
+     * @param req.userPrompt The user's message or question to send to the AI.
+     * @param req.temperature Optional. Controls randomness in the response (0.0 to 1.0).
+     *                        Lower values make output more focused and deterministic,
+     *                        higher values make it more creative and varied.
+     * @param req.maxTokens Optional. The maximum number of tokens to generate in the response.
+     *                      Controls the length of the AI's output.
+     * @param req.imageUrls Optional. Image URLs to include with the user prompt (Gemini models only).
+     *                      Allows the AI to analyze images and generate structured JSON based on them.
+     *
+     * @returns A promise that resolves to the parsed JSON object generated by the AI.
+     *
+     * @throws An error object if the API request fails or if the response is not valid JSON.
      */
-    async getTranslationStatus(lng) {
-        const env = getKmEnv();
-        if (env.dev) {
-            // In dev, only local languages are available
-            const localLanguages = this.getLanguages();
-            const namespaces = this.getNamespaces();
-            const isLocal = localLanguages.includes(lng);
-            const status = isLocal ? "available" : "not_available";
-            return {
-                status,
-                namespaces: Object.fromEntries(namespaces.map((ns) => [ns, status])),
-            };
-        }
-        const res = await fetch(`${this.client.apiUrl}/i18n/${encodeURIComponent(lng)}/status`, {
-            method: "GET",
-            headers: this.client.apiHeaders,
+    async generateJson(req) {
+        const { content } = await this.chat({
+            ...req,
+            responseMimeType: "application/json",
         });
-        return await res.json();
+        return JSON.parse(content);
     }
     /**
-     * Request AI translation for a target language.
-     *
-     * Triggers background AI translation jobs for all namespaces that are not yet available.
-     * Uses the build's configured primary language as the source.
-     *
-     * In development, returns 'already_available' for local languages and throws an error for others.
-     * In production, triggers the API to start translation.
-     *
-     * @param lng - Target language code (e.g., 'de', 'fr', 'es')
-     * @returns Promise with the result of the request
-     *
-     * @example
-     * ```typescript
-     * const result = await kmClient.i18n.requestTranslation('de');
-     *
-     * if (result.status === 'started') {
-     *   // Translation started, poll for status
-     *   const checkStatus = async () => {
-     *     const status = await kmClient.i18n.getTranslationStatus('de');
-     *     if (status.status === 'available') {
-     *       i18next.changeLanguage('de');
-     *     } else if (status.status === 'processing') {
-     *       setTimeout(checkStatus, 2000);
-     *     }
-     *   };
-     *   checkStatus();
-     * } else if (result.status === 'already_available') {
-     *   // Already translated, switch immediately
-     *   i18next.changeLanguage('de');
-     * }
-     * ```
+     * Modify an image using the AI service.
+     * @param baseImageUrl The URL of the base image to modify.
+     * @param prompt The modification prompt to apply to the image.
+     * @param tags Optional. Tags to associate with the image.
+     * @returns A promise that resolves to the modified image upload information.
      */
-    async requestTranslation(lng) {
-        const env = getKmEnv();
-        if (env.dev) {
-            // In dev, only local languages are available
-            const localLanguages = this.getLanguages();
-            if (localLanguages.includes(lng)) {
-                return { status: "already_available" };
-            }
-            // AI translation not available in dev mode
-            throw new Error(`AI translation not available in dev mode. Add local translations for '${lng}' in src/i18n/${lng}/`);
-        }
-        const res = await fetch(`${this.client.apiUrl}/i18n/${encodeURIComponent(lng)}/translate`, {
+    async modifyImage(baseImageUrl, prompt, tags = [], model = "gemini-2.5-flash-image") {
+        const res = await fetch(`${this.client.apiUrl}/ai/modify-image`, {
             method: "POST",
             headers: this.client.apiHeaders,
+            body: JSON.stringify({ baseImageUrl, prompt, tags, model }),
         });
+        if (!res.ok) {
+            throw await res.json();
+        }
         return await res.json();
     }
 }
@@ -13865,16 +12127,16 @@ var functionApply = Function.prototype.apply;
 /** @type {import('./reflectApply')} */
 var reflectApply$1 = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
 
-var bind$5 = functionBind;
+var bind$4 = functionBind;
 
 var $apply$2 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply$1;
 
 /** @type {import('./actualApply')} */
-var actualApply$1 = $reflectApply || bind$5.call($call$2, $apply$2);
+var actualApply$1 = $reflectApply || bind$4.call($call$2, $apply$2);
 
-var bind$4 = functionBind;
+var bind$3 = functionBind;
 var $TypeError$4 = requireType();
 
 var $call$1 = functionCall;
@@ -13885,7 +12147,7 @@ var callBindApplyHelpers = function callBindBasic(args) {
 	if (args.length < 1 || typeof args[0] !== 'function') {
 		throw new $TypeError$4('a function is required');
 	}
-	return $actualApply(bind$4, $call$1, args);
+	return $actualApply(bind$3, $call$1, args);
 };
 
 var callBind$2 = callBindApplyHelpers;
@@ -13943,12 +12205,21 @@ var getProto$4 = reflectGetProto
 			}
 			: null;
 
-var call = Function.prototype.call;
-var $hasOwn = Object.prototype.hasOwnProperty;
-var bind$3 = functionBind;
+var hasown;
+var hasRequiredHasown;
 
-/** @type {import('.')} */
-var hasown = bind$3.call(call, $hasOwn);
+function requireHasown () {
+	if (hasRequiredHasown) return hasown;
+	hasRequiredHasown = 1;
+
+	var call = Function.prototype.call;
+	var $hasOwn = Object.prototype.hasOwnProperty;
+	var bind = functionBind;
+
+	/** @type {import('.')} */
+	hasown = bind.call(call, $hasOwn);
+	return hasown;
+}
 
 var undefined$1;
 
@@ -14191,7 +12462,7 @@ var LEGACY_ALIASES = {
 };
 
 var bind$2 = functionBind;
-var hasOwn$1 = hasown;
+var hasOwn$1 = requireHasown();
 var $concat = bind$2.call($call, Array.prototype.concat);
 var $spliceApply = bind$2.call($apply$1, Array.prototype.splice);
 var $replace = bind$2.call($call, String.prototype.replace);
@@ -14390,7 +12661,7 @@ var isArguments = supportsStandardArguments ? isStandardArguments : isLegacyArgu
 
 var callBound$3 = callBound$5;
 var hasToStringTag$3 = shams();
-var hasOwn = hasown;
+var hasOwn = requireHasown();
 var gOPD$2 = gopd$1;
 
 /** @type {import('.')} */
@@ -14620,12 +12891,12 @@ var isCallable$1 = reflectApply
 var isCallable = isCallable$1;
 
 var toStr = Object.prototype.toString;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 
 /** @type {<This, A extends readonly unknown[]>(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */
 var forEachArray = function forEachArray(array, iterator, receiver) {
     for (var i = 0, len = array.length; i < len; i++) {
-        if (hasOwnProperty.call(array, i)) {
+        if (hasOwnProperty$1.call(array, i)) {
             if (receiver == null) {
                 iterator(array[i], i, array);
             } else {
@@ -14650,7 +12921,7 @@ var forEachString = function forEachString(string, iterator, receiver) {
 /** @type {<This, O>(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */
 var forEachObject = function forEachObject(object, iterator, receiver) {
     for (var k in object) {
-        if (hasOwnProperty.call(object, k)) {
+        if (hasOwnProperty$1.call(object, k)) {
             if (receiver == null) {
                 iterator(object[k], k, object);
             } else {
@@ -16784,7 +15055,7 @@ const createHandlerDefault = (isInitializing, addPropListener, removePropListene
     removePropListener(prop);
     const deleted = Reflect.deleteProperty(target, prop);
     if (deleted) {
-      notifyUpdate(createOp == null ? void 0 : createOp("delete", prop, prevValue));
+      notifyUpdate(["delete", [prop], prevValue]);
     }
     return deleted;
   },
@@ -16801,11 +15072,10 @@ const createHandlerDefault = (isInitializing, addPropListener, removePropListene
     const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
     addPropListener(prop, nextValue);
     Reflect.set(target, prop, nextValue, receiver);
-    notifyUpdate(createOp == null ? void 0 : createOp("set", prop, value, prevValue));
+    notifyUpdate(["set", [prop], value, prevValue]);
     return true;
   }
 });
-const createOpDefault = (type, prop, ...args) => [type, [prop], ...args];
 const proxyStateMap = /* @__PURE__ */ new WeakMap();
 const refSet = /* @__PURE__ */ new WeakSet();
 const snapCache = /* @__PURE__ */ new WeakMap();
@@ -16816,7 +15086,6 @@ let newProxy = (target, handler) => new Proxy(target, handler);
 let canProxy = canProxyDefault;
 let createSnapshot = createSnapshotDefault;
 let createHandler = createHandlerDefault;
-let createOp;
 function proxy(baseObject = {}) {
   if (!isObject(baseObject)) {
     throw new Error("object required");
@@ -16847,11 +15116,8 @@ function proxy(baseObject = {}) {
     return version;
   };
   const createPropListener = (prop) => (op, nextVersion) => {
-    let newOp;
-    if (op) {
-      newOp = [...op];
-      newOp[1] = [prop, ...newOp[1]];
-    }
+    const newOp = [...op];
+    newOp[1] = [prop, ...newOp[1]];
     notifyUpdate(newOp, nextVersion);
   };
   const propProxyStates = /* @__PURE__ */ new Map();
@@ -16938,9 +15204,7 @@ function subscribe(proxyObject, callback, notifyInSync) {
   const addListener = proxyState[2];
   let isListenerActive = false;
   const listener = (op) => {
-    if (op) {
-      ops.push(op);
-    }
+    ops.push(op);
     if (notifyInSync) {
       callback(ops.splice(0));
       return;
@@ -16973,15 +15237,6 @@ function ref(obj) {
   refSet.add(obj);
   return obj;
 }
-function unstable_enableOp(enabled = true) {
-  if (enabled === true) {
-    createOp = createOpDefault;
-  } else if (enabled === false) {
-    createOp = void 0;
-  } else {
-    createOp = enabled;
-  }
-}
 
 const parseProxyOps = (ops) => {
     const indexed = new Set();
@@ -17955,7 +16210,6 @@ class KokimokiClient extends EventEmitter$1 {
     _clientTokenKey = "KM_TOKEN";
     _editorContext;
     _ai;
-    _i18n;
     _storage;
     _leaderboard;
     constructor(host, appId, code = "") {
@@ -17969,7 +16223,6 @@ class KokimokiClient extends EventEmitter$1 {
         this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
         // Initialize modules
         this._ai = new KokimokiAiService(this);
-        this._i18n = new KokimokiI18nService(this);
         this._storage = new KokimokiStorageService(this);
         this._leaderboard = new KokimokiLeaderboardService(this);
         // Set up ping interval
@@ -18479,44 +16732,6 @@ class KokimokiClient extends EventEmitter$1 {
             clearInterval(this._pingInterval);
         }
     }
-    /**
-     * Waits for all subscriptions to be fully joined.
-     *
-     * This is useful when you need to ensure all stores have completed their initial
-     * synchronization before proceeding (e.g., before running tests or taking snapshots).
-     *
-     * @param timeout - Maximum time to wait in milliseconds (default: 5000ms).
-     * @returns A promise that resolves when all subscriptions are joined, or when timeout is reached.
-     *
-     * @example
-     * ```ts
-     * // Wait for all stores to sync before starting game
-     * await client.waitForSubscriptions();
-     *
-     * // Wait with custom timeout
-     * await client.waitForSubscriptions(10000);
-     * ```
-     */
-    async waitForSubscriptions(timeout = 5000) {
-        const checkInterval = 10;
-        const maxChecks = Math.ceil(timeout / checkInterval);
-        return new Promise((resolve) => {
-            let checks = 0;
-            const intervalId = setInterval(() => {
-                let allJoined = true;
-                for (const subscription of this._subscriptionsByName.values()) {
-                    if (!subscription.joined) {
-                        allJoined = false;
-                        break;
-                    }
-                }
-                if (allJoined || ++checks >= maxChecks) {
-                    clearInterval(intervalId);
-                    resolve();
-                }
-            }, checkInterval);
-        });
-    }
     /**
      * Gets the internal room hash identifier for a store.
      *
@@ -18608,15 +16823,6 @@ class KokimokiClient extends EventEmitter$1 {
         }
         return this._ai;
     }
-    /**
-     * Access i18n URL resolution and translation loading utilities.
-     */
-    get i18n() {
-        if (!this._i18n) {
-            throw new Error("I18n client not initialized");
-        }
-        return this._i18n;
-    }
     /**
      * Access file upload and management for media files, images, and user-generated content.
      */
@@ -18637,25 +16843,576 @@ class KokimokiClient extends EventEmitter$1 {
     }
 }
 
+var react = {exports: {}};
+
+var react_production = {};
+
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+  REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+  REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+  REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+  REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+  REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+  REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+  REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+  REACT_MEMO_TYPE = Symbol.for("react.memo"),
+  REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+  REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+  MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+function getIteratorFn(maybeIterable) {
+  if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+  maybeIterable =
+    (MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL]) ||
+    maybeIterable["@@iterator"];
+  return "function" === typeof maybeIterable ? maybeIterable : null;
+}
+var ReactNoopUpdateQueue = {
+    isMounted: function () {
+      return false;
+    },
+    enqueueForceUpdate: function () {},
+    enqueueReplaceState: function () {},
+    enqueueSetState: function () {}
+  },
+  assign = Object.assign,
+  emptyObject = {};
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context;
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+Component.prototype.isReactComponent = {};
+Component.prototype.setState = function (partialState, callback) {
+  if (
+    "object" !== typeof partialState &&
+    "function" !== typeof partialState &&
+    null != partialState
+  )
+    throw Error(
+      "takes an object of state variables to update or a function which returns an object of state variables."
+    );
+  this.updater.enqueueSetState(this, partialState, callback, "setState");
+};
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+};
+function ComponentDummy() {}
+ComponentDummy.prototype = Component.prototype;
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context;
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+var pureComponentPrototype = (PureComponent.prototype = new ComponentDummy());
+pureComponentPrototype.constructor = PureComponent;
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+var isArrayImpl = Array.isArray;
+function noop() {}
+var ReactSharedInternals = { H: null, A: null, T: null, S: null },
+  hasOwnProperty = Object.prototype.hasOwnProperty;
+function ReactElement(type, key, props) {
+  var refProp = props.ref;
+  return {
+    $$typeof: REACT_ELEMENT_TYPE,
+    type: type,
+    key: key,
+    ref: void 0 !== refProp ? refProp : null,
+    props: props
+  };
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  return ReactElement(oldElement.type, newKey, oldElement.props);
+}
+function isValidElement(object) {
+  return (
+    "object" === typeof object &&
+    null !== object &&
+    object.$$typeof === REACT_ELEMENT_TYPE
+  );
+}
+function escape$1(key) {
+  var escaperLookup = { "=": "=0", ":": "=2" };
+  return (
+    "$" +
+    key.replace(/[=:]/g, function (match) {
+      return escaperLookup[match];
+    })
+  );
+}
+var userProvidedKeyEscapeRegex = /\/+/g;
+function getElementKey(element, index) {
+  return "object" === typeof element && null !== element && null != element.key
+    ? escape$1("" + element.key)
+    : index.toString(36);
+}
+function resolveThenable(thenable) {
+  switch (thenable.status) {
+    case "fulfilled":
+      return thenable.value;
+    case "rejected":
+      throw thenable.reason;
+    default:
+      switch (
+        ("string" === typeof thenable.status
+          ? thenable.then(noop, noop)
+          : ((thenable.status = "pending"),
+            thenable.then(
+              function (fulfilledValue) {
+                "pending" === thenable.status &&
+                  ((thenable.status = "fulfilled"),
+                  (thenable.value = fulfilledValue));
+              },
+              function (error) {
+                "pending" === thenable.status &&
+                  ((thenable.status = "rejected"), (thenable.reason = error));
+              }
+            )),
+        thenable.status)
+      ) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+      }
+  }
+  throw thenable;
+}
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  var type = typeof children;
+  if ("undefined" === type || "boolean" === type) children = null;
+  var invokeCallback = false;
+  if (null === children) invokeCallback = true;
+  else
+    switch (type) {
+      case "bigint":
+      case "string":
+      case "number":
+        invokeCallback = true;
+        break;
+      case "object":
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+            break;
+          case REACT_LAZY_TYPE:
+            return (
+              (invokeCallback = children._init),
+              mapIntoArray(
+                invokeCallback(children._payload),
+                array,
+                escapedPrefix,
+                nameSoFar,
+                callback
+              )
+            );
+        }
+    }
+  if (invokeCallback)
+    return (
+      (callback = callback(children)),
+      (invokeCallback =
+        "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar),
+      isArrayImpl(callback)
+        ? ((escapedPrefix = ""),
+          null != invokeCallback &&
+            (escapedPrefix =
+              invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"),
+          mapIntoArray(callback, array, escapedPrefix, "", function (c) {
+            return c;
+          }))
+        : null != callback &&
+          (isValidElement(callback) &&
+            (callback = cloneAndReplaceKey(
+              callback,
+              escapedPrefix +
+                (null == callback.key ||
+                (children && children.key === callback.key)
+                  ? ""
+                  : ("" + callback.key).replace(
+                      userProvidedKeyEscapeRegex,
+                      "$&/"
+                    ) + "/") +
+                invokeCallback
+            )),
+          array.push(callback)),
+      1
+    );
+  invokeCallback = 0;
+  var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+  if (isArrayImpl(children))
+    for (var i = 0; i < children.length; i++)
+      (nameSoFar = children[i]),
+        (type = nextNamePrefix + getElementKey(nameSoFar, i)),
+        (invokeCallback += mapIntoArray(
+          nameSoFar,
+          array,
+          escapedPrefix,
+          type,
+          callback
+        ));
+  else if (((i = getIteratorFn(children)), "function" === typeof i))
+    for (
+      children = i.call(children), i = 0;
+      !(nameSoFar = children.next()).done;
+
+    )
+      (nameSoFar = nameSoFar.value),
+        (type = nextNamePrefix + getElementKey(nameSoFar, i++)),
+        (invokeCallback += mapIntoArray(
+          nameSoFar,
+          array,
+          escapedPrefix,
+          type,
+          callback
+        ));
+  else if ("object" === type) {
+    if ("function" === typeof children.then)
+      return mapIntoArray(
+        resolveThenable(children),
+        array,
+        escapedPrefix,
+        nameSoFar,
+        callback
+      );
+    array = String(children);
+    throw Error(
+      "Objects are not valid as a React child (found: " +
+        ("[object Object]" === array
+          ? "object with keys {" + Object.keys(children).join(", ") + "}"
+          : array) +
+        "). If you meant to render a collection of children, use an array instead."
+    );
+  }
+  return invokeCallback;
+}
+function mapChildren(children, func, context) {
+  if (null == children) return children;
+  var result = [],
+    count = 0;
+  mapIntoArray(children, result, "", "", function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+function lazyInitializer(payload) {
+  if (-1 === payload._status) {
+    var ctor = payload._result;
+    ctor = ctor();
+    ctor.then(
+      function (moduleObject) {
+        if (0 === payload._status || -1 === payload._status)
+          (payload._status = 1), (payload._result = moduleObject);
+      },
+      function (error) {
+        if (0 === payload._status || -1 === payload._status)
+          (payload._status = 2), (payload._result = error);
+      }
+    );
+    -1 === payload._status && ((payload._status = 0), (payload._result = ctor));
+  }
+  if (1 === payload._status) return payload._result.default;
+  throw payload._result;
+}
+var reportGlobalError =
+    "function" === typeof reportError
+      ? reportError
+      : function (error) {
+          if (
+            "object" === typeof window &&
+            "function" === typeof window.ErrorEvent
+          ) {
+            var event = new window.ErrorEvent("error", {
+              bubbles: true,
+              cancelable: true,
+              message:
+                "object" === typeof error &&
+                null !== error &&
+                "string" === typeof error.message
+                  ? String(error.message)
+                  : String(error),
+              error: error
+            });
+            if (!window.dispatchEvent(event)) return;
+          } else if (
+            "object" === typeof process &&
+            "function" === typeof process.emit
+          ) {
+            process.emit("uncaughtException", error);
+            return;
+          }
+          console.error(error);
+        },
+  Children = {
+    map: mapChildren,
+    forEach: function (children, forEachFunc, forEachContext) {
+      mapChildren(
+        children,
+        function () {
+          forEachFunc.apply(this, arguments);
+        },
+        forEachContext
+      );
+    },
+    count: function (children) {
+      var n = 0;
+      mapChildren(children, function () {
+        n++;
+      });
+      return n;
+    },
+    toArray: function (children) {
+      return (
+        mapChildren(children, function (child) {
+          return child;
+        }) || []
+      );
+    },
+    only: function (children) {
+      if (!isValidElement(children))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return children;
+    }
+  };
+react_production.Activity = REACT_ACTIVITY_TYPE;
+react_production.Children = Children;
+react_production.Component = Component;
+react_production.Fragment = REACT_FRAGMENT_TYPE;
+react_production.Profiler = REACT_PROFILER_TYPE;
+react_production.PureComponent = PureComponent;
+react_production.StrictMode = REACT_STRICT_MODE_TYPE;
+react_production.Suspense = REACT_SUSPENSE_TYPE;
+react_production.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE =
+  ReactSharedInternals;
+react_production.__COMPILER_RUNTIME = {
+  __proto__: null,
+  c: function (size) {
+    return ReactSharedInternals.H.useMemoCache(size);
+  }
+};
+react_production.cache = function (fn) {
+  return function () {
+    return fn.apply(null, arguments);
+  };
+};
+react_production.cacheSignal = function () {
+  return null;
+};
+react_production.cloneElement = function (element, config, children) {
+  if (null === element || void 0 === element)
+    throw Error(
+      "The argument must be a React element, but you passed " + element + "."
+    );
+  var props = assign({}, element.props),
+    key = element.key;
+  if (null != config)
+    for (propName in (void 0 !== config.key && (key = "" + config.key), config))
+      !hasOwnProperty.call(config, propName) ||
+        "key" === propName ||
+        "__self" === propName ||
+        "__source" === propName ||
+        ("ref" === propName && void 0 === config.ref) ||
+        (props[propName] = config[propName]);
+  var propName = arguments.length - 2;
+  if (1 === propName) props.children = children;
+  else if (1 < propName) {
+    for (var childArray = Array(propName), i = 0; i < propName; i++)
+      childArray[i] = arguments[i + 2];
+    props.children = childArray;
+  }
+  return ReactElement(element.type, key, props);
+};
+react_production.createContext = function (defaultValue) {
+  defaultValue = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    _currentValue: defaultValue,
+    _currentValue2: defaultValue,
+    _threadCount: 0,
+    Provider: null,
+    Consumer: null
+  };
+  defaultValue.Provider = defaultValue;
+  defaultValue.Consumer = {
+    $$typeof: REACT_CONSUMER_TYPE,
+    _context: defaultValue
+  };
+  return defaultValue;
+};
+react_production.createElement = function (type, config, children) {
+  var propName,
+    props = {},
+    key = null;
+  if (null != config)
+    for (propName in (void 0 !== config.key && (key = "" + config.key), config))
+      hasOwnProperty.call(config, propName) &&
+        "key" !== propName &&
+        "__self" !== propName &&
+        "__source" !== propName &&
+        (props[propName] = config[propName]);
+  var childrenLength = arguments.length - 2;
+  if (1 === childrenLength) props.children = children;
+  else if (1 < childrenLength) {
+    for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
+      childArray[i] = arguments[i + 2];
+    props.children = childArray;
+  }
+  if (type && type.defaultProps)
+    for (propName in ((childrenLength = type.defaultProps), childrenLength))
+      void 0 === props[propName] &&
+        (props[propName] = childrenLength[propName]);
+  return ReactElement(type, key, props);
+};
+react_production.createRef = function () {
+  return { current: null };
+};
+react_production.forwardRef = function (render) {
+  return { $$typeof: REACT_FORWARD_REF_TYPE, render: render };
+};
+react_production.isValidElement = isValidElement;
+react_production.lazy = function (ctor) {
+  return {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: { _status: -1, _result: ctor },
+    _init: lazyInitializer
+  };
+};
+react_production.memo = function (type, compare) {
+  return {
+    $$typeof: REACT_MEMO_TYPE,
+    type: type,
+    compare: void 0 === compare ? null : compare
+  };
+};
+react_production.startTransition = function (scope) {
+  var prevTransition = ReactSharedInternals.T,
+    currentTransition = {};
+  ReactSharedInternals.T = currentTransition;
+  try {
+    var returnValue = scope(),
+      onStartTransitionFinish = ReactSharedInternals.S;
+    null !== onStartTransitionFinish &&
+      onStartTransitionFinish(currentTransition, returnValue);
+    "object" === typeof returnValue &&
+      null !== returnValue &&
+      "function" === typeof returnValue.then &&
+      returnValue.then(noop, reportGlobalError);
+  } catch (error) {
+    reportGlobalError(error);
+  } finally {
+    null !== prevTransition &&
+      null !== currentTransition.types &&
+      (prevTransition.types = currentTransition.types),
+      (ReactSharedInternals.T = prevTransition);
+  }
+};
+react_production.unstable_useCacheRefresh = function () {
+  return ReactSharedInternals.H.useCacheRefresh();
+};
+react_production.use = function (usable) {
+  return ReactSharedInternals.H.use(usable);
+};
+react_production.useActionState = function (action, initialState, permalink) {
+  return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+};
+react_production.useCallback = function (callback, deps) {
+  return ReactSharedInternals.H.useCallback(callback, deps);
+};
+react_production.useContext = function (Context) {
+  return ReactSharedInternals.H.useContext(Context);
+};
+react_production.useDebugValue = function () {};
+react_production.useDeferredValue = function (value, initialValue) {
+  return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+};
+react_production.useEffect = function (create, deps) {
+  return ReactSharedInternals.H.useEffect(create, deps);
+};
+react_production.useEffectEvent = function (callback) {
+  return ReactSharedInternals.H.useEffectEvent(callback);
+};
+react_production.useId = function () {
+  return ReactSharedInternals.H.useId();
+};
+react_production.useImperativeHandle = function (ref, create, deps) {
+  return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+};
+react_production.useInsertionEffect = function (create, deps) {
+  return ReactSharedInternals.H.useInsertionEffect(create, deps);
+};
+react_production.useLayoutEffect = function (create, deps) {
+  return ReactSharedInternals.H.useLayoutEffect(create, deps);
+};
+react_production.useMemo = function (create, deps) {
+  return ReactSharedInternals.H.useMemo(create, deps);
+};
+react_production.useOptimistic = function (passthrough, reducer) {
+  return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+};
+react_production.useReducer = function (reducer, initialArg, init) {
+  return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+};
+react_production.useRef = function (initialValue) {
+  return ReactSharedInternals.H.useRef(initialValue);
+};
+react_production.useState = function (initialState) {
+  return ReactSharedInternals.H.useState(initialState);
+};
+react_production.useSyncExternalStore = function (
+  subscribe,
+  getSnapshot,
+  getServerSnapshot
+) {
+  return ReactSharedInternals.H.useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot
+  );
+};
+react_production.useTransition = function () {
+  return ReactSharedInternals.H.useTransition();
+};
+react_production.version = "19.2.3";
+
+{
+  react.exports = react_production;
+}
+
+var reactExports = react.exports;
+
 const useAffectedDebugValue = (state, affected) => {
-  const pathList = useRef(void 0);
-  useEffect(() => {
+  const pathList = reactExports.useRef(void 0);
+  reactExports.useEffect(() => {
     pathList.current = affectedToPathList(state, affected);
   });
-  useDebugValue(pathList.current);
+  reactExports.useDebugValue(pathList.current);
 };
 const condUseAffectedDebugValue = useAffectedDebugValue;
 const targetCache = /* @__PURE__ */ new WeakMap();
 function useSnapshot(proxyObject, options) {
   const notifyInSync = options == null ? void 0 : options.sync;
-  const affected = useMemo(
+  const affected = reactExports.useMemo(
     () => proxyObject && /* @__PURE__ */ new WeakMap(),
     [proxyObject]
   );
-  const lastSnapshot = useRef(void 0);
-  const subscribed = useRef(false);
-  const currSnapshot = useSyncExternalStore(
-    useCallback(
+  const lastSnapshot = reactExports.useRef(void 0);
+  const subscribed = reactExports.useRef(false);
+  const currSnapshot = reactExports.useSyncExternalStore(
+    reactExports.useCallback(
       (callback) => {
         subscribed.current = true;
         const unsub = subscribe(proxyObject, callback, notifyInSync);
@@ -18684,13 +17441,13 @@ function useSnapshot(proxyObject, options) {
     },
     () => snapshot(proxyObject)
   );
-  useLayoutEffect(() => {
+  reactExports.useLayoutEffect(() => {
     lastSnapshot.current = currSnapshot;
   });
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
     condUseAffectedDebugValue(currSnapshot, affected);
   }
-  const proxyCache = useMemo(() => /* @__PURE__ */ new WeakMap(), []);
+  const proxyCache = reactExports.useMemo(() => /* @__PURE__ */ new WeakMap(), []);
   return createProxy(currSnapshot, affected, proxyCache, targetCache);
 }
 
@@ -18947,14 +17704,7 @@ function subscribeKey(proxyObject, key, callback, notifyInSync) {
 }
 
 let currentCleanups;
-let didWarnDeprecation = false;
 function watch(callback, options) {
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !didWarnDeprecation) {
-    console.warn(
-      "[DEPRECATED] The `watch` util is no longer maintained. Please migrate to [valtio-reactive](https://github.com/valtiojs/valtio-reactive)."
-    );
-    didWarnDeprecation = true;
-  }
   let alive = true;
   const cleanups = /* @__PURE__ */ new Set();
   const subscriptions = /* @__PURE__ */ new Map();
@@ -19010,7 +17760,7 @@ function watch(callback, options) {
   return cleanup;
 }
 
-const DEVTOOLS = /* @__PURE__ */ Symbol();
+const DEVTOOLS = Symbol();
 function devtools(proxyObject, options) {
   const { enabled, name = "", ...rest } = options || {};
   let extension;
@@ -19024,11 +17774,10 @@ function devtools(proxyObject, options) {
     }
     return;
   }
-  unstable_enableOp();
   let isTimeTraveling = false;
   const devtools2 = extension.connect({ name, ...rest });
-  const unsub1 = subscribe(proxyObject, (unstable_ops) => {
-    const action = unstable_ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
+  const unsub1 = subscribe(proxyObject, (ops) => {
+    const action = ops.filter(([_, path]) => path[0] !== DEVTOOLS).map(([op, path]) => `${op}:${path.map(String).join(".")}`).join(", ");
     if (!action) {
       return;
     }
@@ -19089,12 +17838,12 @@ function devtools(proxyObject, options) {
   };
 }
 
-const DUMMY_SYMBOL = /* @__PURE__ */ Symbol();
+const DUMMY_SYMBOL = Symbol();
 function useProxy(proxy, options) {
   const snapshot = useSnapshot(proxy, options);
   snapshot[DUMMY_SYMBOL];
   let isRendering = true;
-  useLayoutEffect(() => {
+  reactExports.useLayoutEffect(() => {
     isRendering = false;
   });
   return new Proxy(proxy, {
@@ -19104,5 +17853,5 @@ function useProxy(proxy, options) {
   });
 }
 
-export { KokimokiClient, KokimokiStore, derive, devtools, getKmEnv, proxy, ref, snapshot, subscribe, subscribeKey, underive, useProxy, useSnapshot, watch };
+export { KokimokiClient, KokimokiStore, derive, devtools, proxy, ref, snapshot, subscribe, subscribeKey, underive, useProxy, useSnapshot, watch };
 //# sourceMappingURL=kokimoki.min.js.map