lib0 0.2.116 → 1.0.0-0

package/{environment.js → src/environment.js}

@@ -10,16 +10,13 @@ import * as conditions from './conditions.js'
 import * as storage from './storage.js'
 import * as f from './function.js'
 
-/* c8 ignore next 2 */
-// @ts-ignore
-export const isNode = typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'
+/* c8 ignore next */
+export const isNode = /* @__PURE__ */(() => typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]')()
 
 /* c8 ignore next */
-export const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode
-/* c8 ignore next 3 */
-export const isMac = typeof navigator !== 'undefined'
-  ? /Mac/.test(navigator.platform)
-  : false
+export const isBrowser = /* @__PURE__ */(() => typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode)()
+/* c8 ignore next */
+export const isMac = /* @__PURE__ */(() => typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false)()
 
 /**
  * @type {Map<string,string>}
@@ -28,6 +25,7 @@ let params
 const args = []
 
 /* c8 ignore start */
+/* @__NO_SIDE_EFFECTS__ */
 const computeParams = () => {
   if (params === undefined) {
     if (isNode) {
@@ -76,6 +74,7 @@ const computeParams = () => {
  * @return {boolean}
  */
 /* c8 ignore next */
+/* @__NO_SIDE_EFFECTS__ */
 export const hasParam = (name) => computeParams().has(name)
 
 /**
@@ -84,6 +83,7 @@ export const hasParam = (name) => computeParams().has(name)
  * @return {string}
  */
 /* c8 ignore next 2 */
+/* @__NO_SIDE_EFFECTS__ */
 export const getParam = (name, defaultVal) =>
   computeParams().get(name) || defaultVal
 
@@ -92,6 +92,7 @@ export const getParam = (name, defaultVal) =>
  * @return {string|null}
  */
 /* c8 ignore next 4 */
+/* @__NO_SIDE_EFFECTS__ */
 export const getVariable = (name) =>
   isNode
     ? conditions.undefinedToNull(process.env[name.toUpperCase().replaceAll('-', '_')])
@@ -102,34 +103,36 @@ export const getVariable = (name) =>
  * @return {string|null}
  */
 /* c8 ignore next 2 */
-export const getConf = (name) =>
-  computeParams().get('--' + name) || getVariable(name)
+/* @__NO_SIDE_EFFECTS__ */
+export const getConf = (name) => computeParams().get('--' + name) || getVariable(name)
 
 /**
  * @param {string} name
  * @return {string}
  */
-/* c8 ignore next 5 */
+/* c8 ignore start */
+/* @__NO_SIDE_EFFECTS__ */
 export const ensureConf = (name) => {
   const c = getConf(name)
   if (c == null) throw new Error(`Expected configuration "${name.toUpperCase().replaceAll('-', '_')}"`)
   return c
 }
+/* c8 ignore stop */
 
 /**
  * @param {string} name
  * @return {boolean}
  */
 /* c8 ignore next 2 */
+/* @__NO_SIDE_EFFECTS__ */
 export const hasConf = (name) =>
   hasParam('--' + name) || getVariable(name) !== null
 
 /* c8 ignore next */
-export const production = hasConf('production')
+export const production = /* @__PURE__ */(() => hasConf('production'))()
 
 /* c8 ignore next 2 */
-const forceColor = isNode &&
-  f.isOneOf(process.env.FORCE_COLOR, ['true', '1', '2'])
+const forceColor = /* @__PURE__ */(() => isNode && f.isOneOf(process.env.FORCE_COLOR, ['true', '1', '2']))()
 
 /* c8 ignore start */
 /**
@@ -139,7 +142,7 @@ const forceColor = isNode &&
  * Disable color using `--no-color` parameter or using `NO_COLOR=1` environment variable.
  * `FORCE_COLOR=1` enables color and takes precedence over all.
  */
-export const supportsColor = forceColor || (
+export const supportsColor = /* @__PURE__ */(() => forceColor || (
   !hasParam('--no-colors') && // @todo deprecate --no-colors
   !hasConf('no-color') &&
   (!isNode || process.stdout.isTTY) && (
@@ -148,5 +151,16 @@ export const supportsColor = forceColor || (
     getVariable('COLORTERM') !== null ||
     (getVariable('TERM') || '').includes('color')
   )
-)
+))()
 /* c8 ignore stop */
+
+/* c8 ignore start */
+const globalScope = /* @__PURE__ */(() =>/** @type {any} */ (typeof globalThis !== 'undefined'
+  ? globalThis
+  : typeof window !== 'undefined'
+    ? window
+    // @ts-ignore
+    : typeof global !== 'undefined' ? global : {}))()
+/* c8 ignore stop */
+
+export { globalScope as global }

package/{hash → src/hash}/rabin.js

@@ -8,18 +8,18 @@
 import * as buffer from '../buffer.js'
 import * as map from '../map.js'
 
-export const StandardIrreducible8 = new Uint8Array([1, 221])
-export const StandardIrreducible16 = new Uint8Array([1, 244, 157])
-export const StandardIrreducible32 = new Uint8Array([1, 149, 183, 205, 191])
-export const StandardIrreducible64 = new Uint8Array([1, 133, 250, 114, 193, 250, 28, 193, 231])
-export const StandardIrreducible128 = new Uint8Array([1, 94, 109, 166, 228, 6, 222, 102, 239, 27, 128, 184, 13, 50, 112, 169, 199])
+export const StandardIrreducible8 = /* @__PURE__ */new Uint8Array([1, 221])
+export const StandardIrreducible16 = /* @__PURE__ */new Uint8Array([1, 244, 157])
+export const StandardIrreducible32 = /* @__PURE__ */new Uint8Array([1, 149, 183, 205, 191])
+export const StandardIrreducible64 = /* @__PURE__ */new Uint8Array([1, 133, 250, 114, 193, 250, 28, 193, 231])
+export const StandardIrreducible128 = /* @__PURE__ */new Uint8Array([1, 94, 109, 166, 228, 6, 222, 102, 239, 27, 128, 184, 13, 50, 112, 169, 199])
 
 /**
  * Maps from a modulo to the precomputed values.
  *
  * @type {Map<string,Uint8Array>}
  */
-const _precomputedFingerprintCache = new Map()
+const _precomputedFingerprintCache = /* @__PURE__ */new Map()
 
 /**
  * @param {Uint8Array} m

package/{schema.js → src/schema.js}

@@ -13,6 +13,8 @@ import * as fun from './function.js'
 import * as string from './string.js'
 import * as prng from './prng.js'
 import * as number from './number.js'
+import * as map from './map.js'
+import { global } from './environment.js'
 
 /**
  * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
@@ -64,8 +66,6 @@ import * as number from './number.js'
  * } Intersect
  */
 
-const schemaSymbol = Symbol('0schema')
-
 export class ValidationError {
   constructor () {
     /**
@@ -87,7 +87,7 @@ export class ValidationError {
 
   toString () {
     const s = []
-    for (let i = this._rerrs.length - 1; i > 0; i--) {
+    for (let i = this._rerrs.length - 1; i >= 0; i--) {
       const r = this._rerrs[i]
       /* c8 ignore next */
       s.push(string.repeat(' ', (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ''}${r.has} doesn't match ${r.expected}. ${r.message}`)
@@ -101,23 +101,35 @@ export class ValidationError {
  * @param {any} b
  * @return {boolean}
  */
-const shapeExtends = (a, b) => {
+/* @__NO_SIDE_EFFECTS__ */
+const _extendsShapeHelper = (a, b) => {
   if (a === b) return true
   if (a == null || b == null || a.constructor !== b.constructor) return false
   if (a[equalityTraits.EqualityTraitSymbol]) return equalityTraits.equals(a, b) // last resort: check equality (do this before array and obj check which don't implement the equality trait)
   if (arr.isArray(a)) {
     return arr.every(a, aitem =>
-      arr.some(b, bitem => shapeExtends(aitem, bitem))
+      arr.some(b, bitem => _extendsShapeHelper(aitem, bitem))
     )
   } else if (obj.isObject(a)) {
     return obj.every(a, (aitem, akey) =>
-      shapeExtends(aitem, b[akey])
+      _extendsShapeHelper(aitem, b[akey])
     )
   }
   /* c8 ignore next */
   return false
 }
 
+/**
+ * @param {Schema<any>} a
+ * @param {Schema<any>} b
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const extendsShape = (a, b) => {
+  const aShape = /** @type {any} */ (a).shape
+  const bShape = /** @type {any} */ (b).shape
+  return /** @type {any} */ (a.constructor)._dilutes ? _extendsShapeHelper(bShape, aShape) : _extendsShapeHelper(aShape, bShape)
+}
+
 /**
  * @template T
  * @implements {equalityTraits.EqualityTrait}
@@ -131,15 +143,6 @@ export class Schema {
    */
   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.
@@ -150,8 +153,6 @@ export class Schema {
     return this.constructor === other.constructor && fun.equalityDeep(this.shape, other.shape)
   }
 
-  [schemaSymbol] () { return true }
-
   /**
    * @param {object} other
    */
@@ -280,6 +281,7 @@ export class $ConstructedBy extends Schema {
  * @param {((o:Instance<C>) => boolean)|null} check
  * @return {CastToSchema<$ConstructedBy<C>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $constructedBy = (c, check = null) => new $ConstructedBy(c, check)
 export const $$constructedBy = $constructedBy($ConstructedBy)
 
@@ -317,9 +319,49 @@ export class $Custom extends Schema {
  * @param {(o:any) => boolean} check
  * @return {Schema<any>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $custom = (check) => new $Custom(check)
 export const $$custom = $constructedBy($Custom)
 
+/**
+ * @extends {Schema<{$type: Schema<any>}>}
+ */
+export class $Type extends Schema {
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  check (o, err) {
+    const c = o && (o.$type === this)
+    /* c8 ignore next */
+    !c && err?.extend(null, 'type check on', o?.constructor.name, 'failed')
+    return c
+  }
+}
+
+/**
+ * A shared gobal namespace to store schemas across lib0 installations
+ */
+const schemaStore = /* @__PURE__ */(() => {
+  const _ns = '_lib0@v1/$'
+  return (global[_ns] = (global[_ns] || new Map()))
+})()
+
+/**
+ * Define a schema for a type that can validate instances across duplicated module installations.
+ *
+ * Use this if you need to validate duplicated classes from other (duplicate) installations of your
+ * js module. Don't use this only if needed and not as some "standard practice".
+ *
+ * @param {string} uniqueName
+ * @param {number} version
+ * @return {Schema<{ $type: Schema<any> }>}
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const $type = (uniqueName, version = 0) => map.setIfUndefined(schemaStore, `${uniqueName}@v${version}`, () => new $Type())
+export const $$type = $constructedBy($Type)
+
 /**
  * @template {Primitive} T
  * @extends {Schema<T>}
@@ -352,6 +394,7 @@ export class $Literal extends Schema {
  * @param {T} literals
  * @return {CastToSchema<$Literal<T[number]>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $literal = (...literals) => new $Literal(literals)
 export const $$literal = $constructedBy($Literal)
 
@@ -364,14 +407,16 @@ export const $$literal = $constructedBy($Literal)
  * @param {string} str
  * @return {string}
  */
-const _regexEscape = /** @type {any} */ (RegExp).escape || /** @type {(str:string) => string} */ (str =>
-  str.replace(/[().|&,$^[\]]/g, s => '\\' + s)
-)
+/* @__NO_SIDE_EFFECTS__ */
+const _regexEscape = (() =>/** @type {any} */ (RegExp).escape || /** @type {(str:string) => string} */ (str =>
+  str.replace(/[().|&,$^[\]]/g, s => '\\' + s))
+)()
 
 /**
  * @param {string|Schema<any>} s
  * @return {string[]}
  */
+/* @__NO_SIDE_EFFECTS__ */
 const _schemaStringTemplateToRegex = s => {
   if ($string.check(s)) {
     return [_regexEscape(s)]
@@ -425,10 +470,10 @@ export class $StringTemplate extends Schema {
  * @param {T} literals
  * @return {CastToSchema<$StringTemplate<T>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $stringTemplate = (...literals) => new $StringTemplate(literals)
 export const $$stringTemplate = $constructedBy($StringTemplate)
 
-const isOptionalSymbol = Symbol('optional')
 /**
  * @template {Schema<any>} S
  * @extends Schema<Unwrap<S>|undefined>
@@ -453,8 +498,6 @@ class $Optional extends Schema {
     !c && err?.extend(null, 'undefined (optional)', '()')
     return c
   }
-
-  get [isOptionalSymbol] () { return true }
 }
 export const $$optional = $constructedBy($Optional)
 
@@ -477,8 +520,8 @@ class $Never extends Schema {
 /**
  * @type {Schema<never>}
  */
-export const $never = new $Never()
-export const $$never = $constructedBy($Never)
+export const $never = /* @__PURE__ */new $Never()
+export const $$never = /* @__PURE__ */$constructedBy($Never)
 
 /**
  * @template {{ [key: string|symbol|number]: Schema<any> }} S
@@ -543,8 +586,9 @@ export class $Object extends Schema {
  * @param {S} def
  * @return {_ObjectDefToSchema<S> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $object = def => /** @type {any} */ (new $Object(def))
-export const $$object = $constructedBy($Object)
+export const $$object = /* @__PURE__ */$constructedBy($Object)
 /**
  * @type {Schema<{[key:string]: any}>}
  */
@@ -589,8 +633,9 @@ export class $Record extends Schema {
  * @param {Values} values
  * @return {CastToSchema<$Record<Keys,Values>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $record = (keys, values) => new $Record(keys, values)
-export const $$record = $constructedBy($Record)
+export const $$record = /* @__PURE__ */$constructedBy($Record)
 
 /**
  * @template {Schema<any>[]} S
@@ -625,8 +670,9 @@ export class $Tuple extends Schema {
  * @param {T} def
  * @return {CastToSchema<$Tuple<T>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $tuple = (...def) => new $Tuple(def)
-export const $$tuple = $constructedBy($Tuple)
+export const $$tuple = /* @__PURE__ */$constructedBy($Tuple)
 
 /**
  * @template {Schema<any>} S
@@ -662,12 +708,13 @@ export class $Array extends Schema {
  * @param {T} def
  * @return {Schema<Array<T extends Array<Schema<infer S>> ? S : never>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $array = (...def) => new $Array(def)
-export const $$array = $constructedBy($Array)
+export const $$array = /* @__PURE__ */$constructedBy($Array)
 /**
  * @type {Schema<Array<any>>}
  */
-export const $arrayAny = $custom(o => arr.isArray(o))
+export const $arrayAny = /* @__PURE__ */$custom(o => arr.isArray(o))
 
 /**
  * @template T
@@ -703,10 +750,11 @@ export class $InstanceOf extends Schema {
  * @param {((o:T) => boolean)|null} check
  * @return {Schema<T>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $instanceOf = (c, check = null) => new $InstanceOf(c, check)
-export const $$instanceOf = $constructedBy($InstanceOf)
+export const $$instanceOf = /* @__PURE__ */$constructedBy($InstanceOf)
 
-export const $$schema = $instanceOf(Schema)
+export const $$schema = /* @__PURE__ */$instanceOf(Schema)
 
 /**
  * @template {Schema<any>[]} Args
@@ -746,13 +794,14 @@ export class $Lambda extends Schema {
  * @param {Args} args
  * @return {Schema<(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $lambda = (...args) => new $Lambda(args.length > 0 ? args : [$void])
-export const $$lambda = $constructedBy($Lambda)
+export const $$lambda = /* @__PURE__ */$constructedBy($Lambda)
 
 /**
  * @type {Schema<Function>}
  */
-export const $function = $custom(o => typeof o === 'function')
+export const $function = /* @__PURE__ */$custom(o => typeof o === 'function')
 
 /**
  * @template {Array<Schema<any>>} T
@@ -789,16 +838,15 @@ export class $Intersection extends Schema {
  * @param {T} def
  * @return {CastToSchema<$Intersection<T>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $intersect = (...def) => new $Intersection(def)
-export const $$intersect = $constructedBy($Intersection, o => o.shape.length > 0) // Intersection with length=0 is considered "any"
+export const $$intersect = /* @__PURE__ */$constructedBy($Intersection, o => o.shape.length > 0) // Intersection with length=0 is considered "any"
 
 /**
  * @template S
  * @extends {Schema<S>}
  */
 export class $Union extends Schema {
-  static _dilutes = true
-
   /**
    * @param {Array<Schema<S>>} v
    */
@@ -824,55 +872,58 @@ export class $Union extends Schema {
  * @param {T} schemas
  * @return {CastToSchema<$Union<Unwrap<ReadSchema<T>>>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export 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))
-export const $$union = /** @type {Schema<$Union<any>>} */ ($constructedBy($Union))
+export const $$union = /** @type {Schema<$Union<any>>} */ (/* @__PURE__ */$constructedBy($Union))
 
+/* @__NO_SIDE_EFFECTS__ */
 const _t = () => true
 /**
  * @type {Schema<any>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $any = $custom(_t)
-export const $$any = /** @type {Schema<Schema<any>>} */ ($constructedBy($Custom, o => o.shape === _t))
+export const $$any = /** @type {Schema<Schema<any>>} */ (/* @__PURE__ */$constructedBy($Custom, o => o.shape === _t))
 
 /**
  * @type {Schema<bigint>}
  */
-export const $bigint = $custom(o => typeof o === 'bigint')
-export const $$bigint = /** @type {Schema<Schema<BigInt>>} */ ($custom(o => o === $bigint))
+export const $bigint = /* @__PURE__ */$custom(o => typeof o === 'bigint')
+export const $$bigint = /** @type {Schema<Schema<BigInt>>} */ (/* @__PURE__ */$custom(o => o === $bigint))
 
 /**
  * @type {Schema<symbol>}
  */
-export const $symbol = $custom(o => typeof o === 'symbol')
-export const $$symbol = /** @type {Schema<Schema<Symbol>>} */ ($custom(o => o === $symbol))
+export const $symbol = /* @__PURE__ */$custom(o => typeof o === 'symbol')
+export const $$symbol = /** @type {Schema<Schema<Symbol>>} */ (/* @__PURE__ */$custom(o => o === $symbol))
 
 /**
  * @type {Schema<number>}
  */
-export const $number = $custom(o => typeof o === 'number')
-export const $$number = /** @type {Schema<Schema<number>>} */ ($custom(o => o === $number))
+export const $number = /* @__PURE__ */$custom(o => typeof o === 'number')
+export const $$number = /** @type {Schema<Schema<number>>} */ (/* @__PURE__ */$custom(o => o === $number))
 
 /**
  * @type {Schema<string>}
  */
-export const $string = $custom(o => typeof o === 'string')
-export const $$string = /** @type {Schema<Schema<string>>} */ ($custom(o => o === $string))
+export const $string = /* @__PURE__ */$custom(o => typeof o === 'string')
+export const $$string = /** @type {Schema<Schema<string>>} */ (/* @__PURE__ */$custom(o => o === $string))
 
 /**
  * @type {Schema<boolean>}
  */
-export const $boolean = $custom(o => typeof o === 'boolean')
-export const $$boolean = /** @type {Schema<Schema<Boolean>>} */ ($custom(o => o === $boolean))
+export const $boolean = /* @__PURE__ */$custom(o => typeof o === 'boolean')
+export const $$boolean = /** @type {Schema<Schema<Boolean>>} */ (/* @__PURE__ */$custom(o => o === $boolean))
 
 /**
  * @type {Schema<undefined>}
  */
-export const $undefined = $literal(undefined)
-export const $$undefined = /** @type {Schema<Schema<undefined>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined))
+export const $undefined = /* @__PURE__ */$literal(undefined)
+export const $$undefined = /** @type {Schema<Schema<undefined>>} */ (/* @__PURE__ */$constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined))
 
 /**
  * @type {Schema<void>}
@@ -900,7 +951,8 @@ export const $primitive = $union($number, $string, $null, $undefined, $bigint, $
 /**
  * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
  */
-export const $json = (() => {
+/* @__NO_SIDE_EFFECTS__ */
+export const $json = /* @__PURE__ */(() => {
   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)
@@ -945,6 +997,7 @@ export const $json = (() => {
  * @param {IN} o
  * @return {ReadSchema<IN>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const $ = o => {
   if ($$schema.check(o)) {
     return /** @type {any} */ (o)
@@ -975,14 +1028,15 @@ export const $ = o => {
  *
  * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
  */
-export const assert = env.production
+/* @__NO_SIDE_EFFECTS__ */
+export const assert = /* @__PURE__ */(() => env.production
   ? () => {}
   : (o, schema) => {
       const err = new ValidationError()
       if (!schema.check(o, err)) {
         throw error.create(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
       }
-    }
+    })()
 /* c8 ignore end */
 
 /**
@@ -997,6 +1051,8 @@ export const assert = env.production
  * @typedef {ReturnType<Extract<P,Pattern<In extends number ? number : (In extends string ? string : In),any>>['h']>} PatternMatchResult
  */
 
+const unhandledPatternError = 'Unhandled pattern'
+
 /**
  * @todo move this to separate library
  * @template {any} [State=undefined]
@@ -1036,6 +1092,15 @@ export class PatternMatcher {
     return this.if($any, h)
   }
 
+  /**
+   * @param {string} errorMessage
+   */
+  error (errorMessage = unhandledPatternError) {
+    return this.if($any, () => {
+      throw error.create(errorMessage)
+    }).done()
+  }
+
   /**
    * @return {State extends undefined
    *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
@@ -1051,7 +1116,7 @@ export class PatternMatcher {
           return p.h(o, s)
         }
       }
-      throw error.create('Unhandled pattern')
+      throw error.create(unhandledPatternError)
     }
   }
 }
@@ -1061,6 +1126,7 @@ export class PatternMatcher {
  * @param {State} [state]
  * @return {PatternMatcher<State extends undefined ? undefined : Unwrap<ReadSchema<State>>>}
  */
+/* @__NO_SIDE_EFFECTS__ */
 export const match = state => new PatternMatcher(/** @type {any} */ (state))
 
 /**
@@ -1068,7 +1134,7 @@ export const match = state => new PatternMatcher(/** @type {any} */ (state))
  *
  * @type {<T>(o:T,gen:prng.PRNG)=>T}
  */
-const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any))
+const _random = /** @type {any} */ /* @__PURE__ */(() => match(/** @type {Schema<prng.PRNG>} */ ($any))
   .if($$number, (_o, gen) => prng.int53(gen, number.MIN_SAFE_INTEGER, number.MAX_SAFE_INTEGER))
   .if($$string, (_o, gen) => prng.word(gen))
   .if($$boolean, (_o, gen) => prng.bool(gen))
@@ -1125,7 +1191,7 @@ const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any
     }
     return res
   })
-  .done())
+  .done())()
 
 /**
  * @template S
@@ -1133,4 +1199,7 @@ const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any
  * @param {S} schema
  * @return {Unwrap<ReadSchema<S>>}
  */
-export const random = (gen, schema) => /** @type {any} */ (_random($(schema), gen))
+/* @__NO_SIDE_EFFECTS__ */
+export const random = (gen, schema) => /** @type {any} */ (/* @__PURE__ */_random($(schema), gen))
+
+export const ___test = 42