arcane-os 0.5.17 → 0.5.19

package/runtime/strong-type/index.js

@@ -1,352 +1,1276 @@
-class Fake{
-    //fake class as fallback
-}
-
-class FakeCore{
-    //fake class as fallback
-}
-
-class Is{
-    constructor(strict=true){
-        this.strict=strict;
-    }
-
-    //core
-    throw(valueType,expectedType){
-        let err=new TypeError;
-        err.message=`expected type of ${valueType} to be ${expectedType}`;
-        if(!this.strict){
-            return false;
-        }
-        throw err;
-    }
-
-    typeCheck(value,type){
-        if(typeof value === type){
-            return true;
-        }
-        return this.throw(typeof value,type);
-    }
-
-    instanceCheck(value=new Fake, constructor=FakeCore){
-        //console.log(value,constructor);
-        if(value instanceof constructor){
-            return true;
-        }
-        return this.throw(typeof value,constructor.name);
-    }
-
-    symbolStringCheck(value,type){
-        if(Object.prototype.toString.call(value) == `[object ${type}]`){
-            return true;
-        }
-        return this.throw(Object.prototype.toString.call(value),`[object ${type}]`);
-    }
-
-    compare(value,targetValue,typeName){
-        if(value==targetValue){
-            return true;
-        }
-        
-        if(!this.strict){
-            return false;
-        }
-        throw new Error(`expected ${value} == ${targetValue} but it is not.`);
-    }
-
-    defined(value){
-        const weakIs=new Is(false);
-        if(weakIs.undefined(value)){
-            return this.throw('undefined','defined');
-        }
-
-        return true;
-    }
-
-    any(value){
-        return this.defined(value);
-    }
-
-    exists(value){
-        return this.defined(value);
-    }
-
-    union(value,typesString){
-        const types=typesString.split('|');
-        const weakIs=new Is(false);
-        let pass=false;
-        let type='undefined';
-        for(type of types){
-            try{
-                if(weakIs[type](value)){
-                    pass=true;
-                    break;
-                }
-            }catch(err){
-                return this.throw(type,'a method available on strong-type');
-            }
-        }
-
-        if(pass){
-           return this[type](value);
-        }
-
-        return this.throw(typeof value, types.join('|'));
-
-    }
-
-    //unique checks
-    finite(value){
-        if(isFinite(value)){
-            return true;
-        }
-        return this.throw(typeof value, 'finite');
-    }
-
-    NaN(value){
-        if(!this.number(value)){
-            return this.number(value);
-        }
-
-        if(isNaN(value)){
-            return true;
-        }
-
-        return this.throw(typeof value, 'NaN');
-    }
-
-    null(value){
-        return this.compare(value,null,'null');
-    }
-
-    //common sugar
-    array(value){
-        return this.instanceCheck(value,Array);
-    }
-
-    boolean(value){
-        return this.typeCheck(value,'boolean');
-    }
-
-    bigInt(value){
-        return this.typeCheck(value,'bigint');
-    }
-
-    date(value){
-        return this.instanceCheck(value,Date);
-    }
-
-    generator(value){
-        return this.symbolStringCheck(value,'Generator');
-    }
-
-    asyncGenerator(value){
-        return this.symbolStringCheck(value,'AsyncGenerator');
-    }
-
-    globalThis(value){
-        return this.compare(value,globalThis,'explicitly globalThis, not window, global nor self');
-    }
-
-    infinity(value){
-        return this.compare(value,Infinity,'Infinity');
-    }
-
-    map(value){
-        return this.instanceCheck(value,Map);
-    }
-
-    weakMap(value){
-        return this.instanceCheck(value,WeakMap);
-    }
-
-    number(value){
-        return this.typeCheck(value,'number');
-    }
-
-    object(value){
-        return this.typeCheck(value,'object');
-    }
-
-    promise(value){
-        return this.instanceCheck(value,Promise);
-    }
-
-    regExp(value){
-        return this.instanceCheck(value,RegExp);
-    }
-    
-    undefined(value){
-        return this.typeCheck(value,'undefined');
-    }
-
-    set(value){
-        return this.instanceCheck(value,Set);
-    }
-
-    weakSet(value){
-        return this.instanceCheck(value,WeakSet);
-    }
-    
-    string(value){
-        return this.typeCheck(value,'string');
-    }
-
-    symbol(value){
-        return this.typeCheck(value,'symbol');
-    }
-
-    //functions
-    function(value){
-        return this.typeCheck(value,'function');
-    }
-
-    asyncFunction(value){
-        return this.symbolStringCheck(value,'AsyncFunction');
-    }
-
-    generatorFunction(value){
-        return this.symbolStringCheck(value,'GeneratorFunction');
-    }
-
-    asyncGeneratorFunction(value){
-        return this.symbolStringCheck(value,'AsyncGeneratorFunction');
-    }
-
-    //error sugar
-    error(value){
-        return this.instanceCheck(value,Error);
-    }
-
-    evalError(value){
-        return this.instanceCheck(value,EvalError);
-    }
-
-    rangeError(value){
-        return this.instanceCheck(value,RangeError);
-    }
-
-    referenceError(value){
-        return this.instanceCheck(value,ReferenceError);
-    }
-
-    syntaxError(value){
-        return this.instanceCheck(value,SyntaxError);
-    }
-
-    typeError(value){
-        return this.instanceCheck(value,TypeError);
-    }
-
-    URIError(value){
-        return this.instanceCheck(value,URIError);
-    }    
-
-    //typed array sugar
-    bigInt64Array(value){
-        return this.instanceCheck(value,BigInt64Array);
-    }
-
-    bigUint64Array(value){
-        return this.instanceCheck(value,BigUint64Array);
-    }
-
-    float32Array(value){
-        return this.instanceCheck(value,Float32Array);
-    }
-
-    float64Array(value){
-        return this.instanceCheck(value,Float64Array);
-    }
-
-    int8Array(value){
-        return this.instanceCheck(value,Int8Array);
-    }
-
-    int16Array(value){
-        return this.instanceCheck(value,Int16Array);
-    }
-
-    int32Array(value){
-        return this.instanceCheck(value,Int32Array);
-    }
-
-    uint8Array(value){
-        return this.instanceCheck(value,Uint8Array);
-    }
-
-    uint8ClampedArray(value){
-        return this.instanceCheck(value,Uint8ClampedArray);
-    }
-    
-    uint16Array(value){
-        return this.instanceCheck(value,Uint16Array);
-    }
-
-    uint32Array(value){
-        return this.instanceCheck(value,Uint32Array);
-    }
-
-    //buffers
-    arrayBuffer(value){
-        return this.instanceCheck(value,ArrayBuffer);
-    }
-
-    dataView(value){
-        return this.instanceCheck(value,DataView);
-    }
-
-    sharedArrayBuffer(value){
-        return this.instanceCheck(value,(function(){try{return SharedArrayBuffer}catch{ return Fake}})());
-    }
-
-    //Intl (browser internationalization)
-    intlDateTimeFormat(value){
-        return this.instanceCheck(value,Intl.DateTimeFormat);
-    }
-
-    intlCollator(value){
-        return this.instanceCheck(value,Intl.Collator);
-    }
-
-    intlDisplayNames(value){
-        return this.instanceCheck(value,Intl.DisplayNames);
-    }
-
-    intlListFormat(value){
-        return this.instanceCheck(value,Intl.ListFormat);
-    }
-
-    intlLocale(value){
-        return this.instanceCheck(value,Intl.Locale);
-    }
-
-    intlNumberFormat(value){
-        return this.instanceCheck(value,Intl.NumberFormat);
-    }
-
-    intlPluralRules(value){
-        return this.instanceCheck(value,Intl.PluralRules);
-    }
-
-    intlRelativeTimeFormat(value){
-        return this.instanceCheck(value,Intl.RelativeTimeFormat);
-    }
-
-    intlRelativeTimeFormat(value){
-        return this.instanceCheck(value,Intl.RelativeTimeFormat);
-    }
-
-
-
-    //garbage collection
-    finalizationRegistry(value){
-        return this.instanceCheck(value,FinalizationRegistry);
-    }
-
-    weakRef(value){
-        return this.instanceCheck(value,WeakRef);
-    }
-}
-
-export {Is as default, Is};
+class Fake{
+    //fake class as fallback
+}
+
+class FakeCore{
+    //fake class as fallback
+}
+
+const brandProbe={};
+const brandFailure=Symbol('strong-type brand failure');
+const noArguments=Object.freeze([]);
+const brandProbeArguments=Object.freeze([brandProbe]);
+const emptyStringArguments=Object.freeze(['']);
+const segmentProbeArguments=Object.freeze([-1]);
+const functionToString=Function.prototype.toString;
+const objectConstructorSource=functionToString.call(Object);
+const objectGetPrototypeOf=Object.getPrototypeOf;
+const reflectApply=Reflect.apply;
+
+const getterFor=function(prototype,property){
+    if(!prototype){
+        return false;
+    }
+
+    try{
+        const descriptor=Object.getOwnPropertyDescriptor(prototype,property);
+        return descriptor && typeof descriptor.get === 'function' ? descriptor.get : false;
+    }catch(err){
+        return false;
+    }
+};
+
+const applyBrand=function(value,check,args=noArguments){
+    if(typeof check !== 'function'){
+        return false;
+    }
+
+    try{
+        reflectApply(check,value,args);
+        return true;
+    }catch(err){
+        return false;
+    }
+};
+
+const applyValue=function(value,check,args=noArguments){
+    if(typeof check !== 'function'){
+        return brandFailure;
+    }
+
+    try{
+        return reflectApply(check,value,args);
+    }catch(err){
+        return brandFailure;
+    }
+};
+
+const methodBrand=function(value,prototype,method,args=noArguments){
+    if(!prototype){
+        return false;
+    }
+
+    let check;
+    try{
+        check=prototype[method];
+    }catch(err){
+        return false;
+    }
+    return applyBrand(value,check,args);
+};
+
+const getterBrand=function(value,prototype,property){
+    return applyBrand(value,getterFor(prototype,property));
+};
+
+const instanceOf=function(value,constructor){
+    if(typeof constructor !== 'function'){
+        return false;
+    }
+
+    try{
+        return value instanceof constructor;
+    }catch(err){
+        return false;
+    }
+};
+
+const stringTagCheck=function(value,type){
+    try{
+        return Object.prototype.toString.call(value) === `[object ${type}]`;
+    }catch(err){
+        return false;
+    }
+};
+
+const arrayBufferByteLengthGetter=getterFor(globalThis.ArrayBuffer && globalThis.ArrayBuffer.prototype,'byteLength');
+const arrayBufferResizableGetter=getterFor(globalThis.ArrayBuffer && globalThis.ArrayBuffer.prototype,'resizable');
+const sharedArrayBufferByteLengthGetter=getterFor(globalThis.SharedArrayBuffer && globalThis.SharedArrayBuffer.prototype,'byteLength');
+const sharedArrayBufferGrowableGetter=getterFor(globalThis.SharedArrayBuffer && globalThis.SharedArrayBuffer.prototype,'growable');
+const dataViewByteLengthGetter=getterFor(globalThis.DataView && globalThis.DataView.prototype,'byteLength');
+const regExpSourceGetter=getterFor(globalThis.RegExp && globalThis.RegExp.prototype,'source');
+const intlDateTimeFormatGetter=getterFor(globalThis.Intl && globalThis.Intl.DateTimeFormat && globalThis.Intl.DateTimeFormat.prototype,'format');
+const intlCollatorCompareGetter=getterFor(globalThis.Intl && globalThis.Intl.Collator && globalThis.Intl.Collator.prototype,'compare');
+const intlNumberFormatGetter=getterFor(globalThis.Intl && globalThis.Intl.NumberFormat && globalThis.Intl.NumberFormat.prototype,'format');
+const dateGetTime=Date.prototype.getTime;
+const mapHas=Map.prototype.has;
+const weakMapHas=WeakMap.prototype.has;
+const setHas=Set.prototype.has;
+const weakSetHas=WeakSet.prototype.has;
+const booleanValueOf=Boolean.prototype.valueOf;
+const numberValueOf=Number.prototype.valueOf;
+const bigIntValueOf=globalThis.BigInt && globalThis.BigInt.prototype.valueOf;
+const stringValueOf=String.prototype.valueOf;
+const symbolValueOf=globalThis.Symbol && globalThis.Symbol.prototype.valueOf;
+
+const arrayBufferCheck=function(value){
+    return applyBrand(value,arrayBufferByteLengthGetter);
+};
+
+const sharedArrayBufferCheck=function(value){
+    return applyBrand(value,sharedArrayBufferByteLengthGetter);
+};
+
+const dataViewCheck=function(value){
+    return applyBrand(value,dataViewByteLengthGetter);
+};
+
+const arrayBufferViewCheck=function(value){
+    try{
+        return ArrayBuffer.isView(value);
+    }catch(err){
+        return false;
+    }
+};
+
+const typedArrayTagGetter=(function(){
+    const prototype=Object.getPrototypeOf(Uint8Array.prototype);
+    const descriptor=Object.getOwnPropertyDescriptor(prototype,Symbol.toStringTag);
+    return descriptor && descriptor.get;
+})();
+
+const typedArrayName=function(value){
+    if(!arrayBufferViewCheck(value) || typeof typedArrayTagGetter !== 'function'){
+        return false;
+    }
+
+    const name=applyValue(value,typedArrayTagGetter);
+    return name === brandFailure ? false : name;
+};
+
+const dateCheck=function(value){
+    return applyBrand(value,dateGetTime);
+};
+
+const validDateCheck=function(value){
+    const time=applyValue(value,dateGetTime);
+    return time !== brandFailure && !Number.isNaN(time);
+};
+
+const mapCheck=function(value){
+    return applyBrand(value,mapHas,brandProbeArguments);
+};
+
+const weakMapCheck=function(value){
+    return applyBrand(value,weakMapHas,brandProbeArguments);
+};
+
+const setCheck=function(value){
+    return applyBrand(value,setHas,brandProbeArguments);
+};
+
+const weakSetCheck=function(value){
+    return applyBrand(value,weakSetHas,brandProbeArguments);
+};
+
+const regExpCheck=function(value){
+    return applyBrand(value,regExpSourceGetter);
+};
+
+const boxedBooleanCheck=function(value){
+    return typeof value === 'object' && value !== null && applyBrand(value,booleanValueOf);
+};
+
+const boxedNumberCheck=function(value){
+    return typeof value === 'object' && value !== null && applyBrand(value,numberValueOf);
+};
+
+const boxedBigIntCheck=function(value){
+    return typeof value === 'object' && value !== null && applyBrand(value,bigIntValueOf);
+};
+
+const boxedStringCheck=function(value){
+    return typeof value === 'object' && value !== null && applyBrand(value,stringValueOf);
+};
+
+const boxedSymbolCheck=function(value){
+    return typeof value === 'object' && value !== null && applyBrand(value,symbolValueOf);
+};
+
+const plainObjectCheck=function(value){
+    if(value === null || typeof value !== 'object'){
+        return false;
+    }
+
+    let prototype;
+    try{
+        prototype=Object.getPrototypeOf(value);
+    }catch(err){
+        return false;
+    }
+    if(prototype === null){
+        return true;
+    }
+
+    if(!Object.prototype.hasOwnProperty.call(prototype,'constructor')){
+        return false;
+    }
+
+    const constructor=prototype.constructor;
+    return typeof constructor === 'function' && functionToString.call(constructor) === objectConstructorSource;
+};
+
+const protocolCheck=function(value,symbol,method){
+    if(value === null || value === undefined){
+        return false;
+    }
+
+    const key=typeof symbol === 'symbol' ? symbol : method;
+    if(typeof key !== 'symbol' && typeof key !== 'string'){
+        return false;
+    }
+
+    try{
+        return typeof value[key] === 'function';
+    }catch(err){
+        return false;
+    }
+};
+
+const blockedUnionMethods=new Set([
+    'constructor',
+    'throw',
+    'check',
+    'typeCheck',
+    'instanceCheck',
+    'symbolStringCheck',
+    'compare',
+    'globalInstanceCheck',
+    'nestedInstanceCheck',
+    'globalValueCheck',
+    'nestedValueCheck',
+    'union'
+]);
+
+const unionNamesCache=new Map;
+const unionNamesCacheLimit=128;
+
+const normalizeUnionNames=function(types){
+    if(typeof types === 'string' && unionNamesCache.has(types)){
+        return unionNamesCache.get(types);
+    }
+
+    const source=Array.isArray(types) ? types : typeof types === 'string' ? types.split('|') : [];
+    const names=[];
+    const length=source.length;
+    for(let index=0;index<length;index++){
+        const type=source[index];
+        if(typeof type !== 'string'){
+            continue;
+        }
+        const name=type.trim();
+        if(name){
+            names.push(name);
+        }
+    }
+
+    if(typeof types === 'string'){
+        if(unionNamesCache.size >= unionNamesCacheLimit){
+            unionNamesCache.delete(unionNamesCache.keys().next().value);
+        }
+        Object.freeze(names);
+        unionNamesCache.set(types,names);
+    }
+    return names;
+};
+
+let cachedSegmenterConstructor;
+let cachedSegmentMethod;
+let cachedSegmentsPrototype;
+let cachedSegmentsContaining;
+const segmentsContainingFor=function(constructor){
+    if(typeof constructor !== 'function'){
+        return false;
+    }
+
+    let segment;
+    try{
+        segment=constructor.prototype && constructor.prototype.segment;
+    }catch(err){
+        return false;
+    }
+    if(typeof segment !== 'function'){
+        return false;
+    }
+    if(constructor === cachedSegmenterConstructor && segment === cachedSegmentMethod && typeof cachedSegmentsContaining === 'function'){
+        try{
+            if(cachedSegmentsPrototype && cachedSegmentsPrototype.containing === cachedSegmentsContaining){
+                return cachedSegmentsContaining;
+            }
+        }catch(err){
+            return false;
+        }
+    }
+
+    try{
+        const prototype=objectGetPrototypeOf(reflectApply(segment,new constructor,emptyStringArguments));
+        const containing=prototype && prototype.containing;
+        if(typeof containing === 'function'){
+            cachedSegmenterConstructor=constructor;
+            cachedSegmentMethod=segment;
+            cachedSegmentsPrototype=prototype;
+            cachedSegmentsContaining=containing;
+            return containing;
+        }
+    }catch(err){
+        return false;
+    }
+    return false;
+};
+
+const validatorFor=function(target,name){
+    if(blockedUnionMethods.has(name)){
+        return false;
+    }
+
+    let current=target;
+    while(current && current !== Object.prototype){
+        const descriptor=Object.getOwnPropertyDescriptor(current,name);
+        if(descriptor && typeof descriptor.value === 'function' && descriptor.value.length <= 1){
+            return descriptor.value;
+        }
+        current=Object.getPrototypeOf(current);
+    }
+
+    return false;
+};
+
+class Is{
+    constructor(strict=true){
+        this.strict=strict;
+    }
+
+    //core
+    throw(valueType,expectedType){
+        if(!this.strict){
+            return false;
+        }
+
+        const err=new TypeError;
+        err.message=`expected type of ${valueType} to be ${expectedType}`;
+        throw err;
+    }
+
+    check(value,pass,expectedType){
+        if(pass){
+            return true;
+        }
+
+        const valueType=value === null ? 'null' : typeof value;
+        return this.throw(valueType,expectedType);
+    }
+
+    typeCheck(value,type){
+        return this.check(value,typeof value === type,type);
+    }
+
+    instanceCheck(value=new Fake,constructor=FakeCore){
+        return this.check(value,instanceOf(value,constructor),constructor && constructor.name ? constructor.name : 'available constructor');
+    }
+
+    symbolStringCheck(value,type){
+        return this.check(value,stringTagCheck(value,type),`[object ${type}]`);
+    }
+
+    compare(value,targetValue,typeName){
+        if(Object.is(value,targetValue)){
+            return this.check(value,true,typeName);
+        }
+
+        const expectedType=typeName === undefined ? String(targetValue) : typeName;
+        return this.check(value,false,expectedType);
+    }
+
+    globalInstanceCheck(value,type){
+        return this.check(value,instanceOf(value,globalThis[type]),type);
+    }
+
+    nestedInstanceCheck(value,container,type){
+        const constructor=container && container[type];
+        return this.check(value,instanceOf(value,constructor),type);
+    }
+
+    globalValueCheck(value,type){
+        const available=Object.prototype.hasOwnProperty.call(globalThis,type);
+        return this.check(value,available && Object.is(value,globalThis[type]),type);
+    }
+
+    nestedValueCheck(value,container,type){
+        const available=container && Object.prototype.hasOwnProperty.call(container,type);
+        return this.check(value,available && Object.is(value,container[type]),type);
+    }
+
+    defined(value){
+        return this.check(value,value !== undefined,'defined');
+    }
+
+    any(value){
+        return this.defined(value);
+    }
+
+    exists(value){
+        return this.defined(value);
+    }
+
+    union(value,typesString){
+        const names=normalizeUnionNames(typesString);
+        if(!names.length){
+            return this.throw(typeof typesString,'a pipe-delimited string or array of strong-type methods');
+        }
+
+        const validators=new Array(names.length);
+        for(let index=0;index<names.length;index++){
+            const validator=validatorFor(this,names[index]);
+            if(!validator){
+                return this.throw(names[index],'a method available on strong-type');
+            }
+            validators[index]=validator;
+        }
+
+        const weakIs=Object.create(this);
+        weakIs.strict=false;
+        for(let index=0;index<validators.length;index++){
+            try{
+                if(validators[index].call(weakIs,value)){
+                    return true;
+                }
+            }catch(err){
+                //custom validators may throw even when strict is false
+            }
+        }
+
+        const fail=this.throw;
+        if(fail === defaultThrow && !this.strict){
+            return false;
+        }
+        return reflectApply(fail,this,[typeof value,names.join('|')]);
+    }
+
+    //values and primitives
+    finite(value){
+        return this.check(value,Number.isFinite(value),'finite number');
+    }
+
+    finiteNumber(value){
+        return this.finite(value);
+    }
+
+    NaN(value){
+        return this.check(value,Number.isNaN(value),'NaN');
+    }
+
+    nan(value){
+        return this.NaN(value);
+    }
+
+    null(value){
+        return this.check(value,value === null,'null');
+    }
+
+    nullish(value){
+        return this.check(value,value === null || value === undefined,'null or undefined');
+    }
+
+    boolean(value){
+        return this.typeCheck(value,'boolean');
+    }
+
+    bigInt(value){
+        return this.typeCheck(value,'bigint');
+    }
+
+    bigint(value){
+        return this.bigInt(value);
+    }
+
+    number(value){
+        return this.typeCheck(value,'number');
+    }
+
+    integer(value){
+        return this.check(value,Number.isInteger(value),'integer');
+    }
+
+    safeInteger(value){
+        return this.check(value,Number.isSafeInteger(value),'safe integer');
+    }
+
+    infinity(value){
+        return this.check(value,value === Infinity,'Infinity');
+    }
+
+    infinite(value){
+        return this.check(value,value === Infinity || value === -Infinity,'positive or negative Infinity');
+    }
+
+    positiveInfinity(value){
+        return this.infinity(value);
+    }
+
+    negativeInfinity(value){
+        return this.check(value,value === -Infinity,'-Infinity');
+    }
+
+    negativeZero(value){
+        return this.check(value,Object.is(value,-0),'-0');
+    }
+
+    string(value){
+        return this.typeCheck(value,'string');
+    }
+
+    symbol(value){
+        return this.typeCheck(value,'symbol');
+    }
+
+    undefined(value){
+        return this.typeCheck(value,'undefined');
+    }
+
+    primitive(value){
+        const type=typeof value;
+        return this.check(value,value === null || (type !== 'object' && type !== 'function'),'primitive');
+    }
+
+    globalThis(value){
+        return this.compare(value,globalThis,'explicitly globalThis, not window, global nor self');
+    }
+
+    atomics(value){
+        return this.globalValueCheck(value,'Atomics');
+    }
+
+    json(value){
+        return this.globalValueCheck(value,'JSON');
+    }
+
+    math(value){
+        return this.globalValueCheck(value,'Math');
+    }
+
+    reflect(value){
+        return this.globalValueCheck(value,'Reflect');
+    }
+
+    rawJSON(value){
+        const check=globalThis.JSON && globalThis.JSON.isRawJSON;
+        let pass=false;
+        try{
+            pass=typeof check === 'function' && check(value);
+        }catch(err){
+            pass=false;
+        }
+        return this.check(value,pass,'raw JSON');
+    }
+
+    //objects and collections
+    array(value){
+        let pass=false;
+        try{
+            pass=Array.isArray(value);
+        }catch(err){
+            pass=false;
+        }
+        return this.check(value,pass,'Array');
+    }
+
+    date(value){
+        return this.check(value,dateCheck(value),'Date');
+    }
+
+    validDate(value){
+        return this.check(value,validDateCheck(value),'valid Date');
+    }
+
+    map(value){
+        return this.check(value,mapCheck(value),'Map');
+    }
+
+    weakMap(value){
+        return this.check(value,weakMapCheck(value),'WeakMap');
+    }
+
+    object(value){
+        return this.typeCheck(value,'object');
+    }
+
+    nonNullObject(value){
+        return this.check(value,value !== null && typeof value === 'object','non-null object');
+    }
+
+    plainObject(value){
+        return this.check(value,plainObjectCheck(value),'plain object');
+    }
+
+    nullPrototypeObject(value){
+        let pass=false;
+        if(value !== null && typeof value === 'object'){
+            try{
+                pass=Object.getPrototypeOf(value) === null;
+            }catch(err){
+                pass=false;
+            }
+        }
+        return this.check(value,pass,'null-prototype object');
+    }
+
+    argumentsObject(value){
+        return this.symbolStringCheck(value,'Arguments');
+    }
+
+    promise(value){
+        return this.globalInstanceCheck(value,'Promise');
+    }
+
+    thenable(value){
+        const pass=value !== null && value !== undefined && (typeof value === 'object' || typeof value === 'function') && protocolCheck(value,false,'then');
+        return this.check(value,pass,'thenable');
+    }
+
+    regExp(value){
+        return this.check(value,regExpCheck(value),'RegExp');
+    }
+
+    regexp(value){
+        return this.regExp(value);
+    }
+
+    set(value){
+        return this.check(value,setCheck(value),'Set');
+    }
+
+    weakSet(value){
+        return this.check(value,weakSetCheck(value),'WeakSet');
+    }
+
+    //boxed primitives
+    boxedPrimitive(value){
+        const pass=boxedBooleanCheck(value) || boxedNumberCheck(value) || boxedBigIntCheck(value) || boxedStringCheck(value) || boxedSymbolCheck(value);
+        return this.check(value,pass,'boxed primitive');
+    }
+
+    booleanObject(value){
+        return this.check(value,boxedBooleanCheck(value),'Boolean object');
+    }
+
+    numberObject(value){
+        return this.check(value,boxedNumberCheck(value),'Number object');
+    }
+
+    bigIntObject(value){
+        return this.check(value,boxedBigIntCheck(value),'BigInt object');
+    }
+
+    stringObject(value){
+        return this.check(value,boxedStringCheck(value),'String object');
+    }
+
+    symbolObject(value){
+        return this.check(value,boxedSymbolCheck(value),'Symbol object');
+    }
+
+    //functions and protocols
+    function(value){
+        return this.typeCheck(value,'function');
+    }
+
+    callable(value){
+        return this.function(value);
+    }
+
+    asyncFunction(value){
+        return this.symbolStringCheck(value,'AsyncFunction');
+    }
+
+    generatorFunction(value){
+        return this.symbolStringCheck(value,'GeneratorFunction');
+    }
+
+    asyncGeneratorFunction(value){
+        return this.symbolStringCheck(value,'AsyncGeneratorFunction');
+    }
+
+    generator(value){
+        return this.symbolStringCheck(value,'Generator');
+    }
+
+    asyncGenerator(value){
+        return this.symbolStringCheck(value,'AsyncGenerator');
+    }
+
+    iterator(value){
+        const pass=value !== null && value !== undefined && protocolCheck(value,false,'next');
+        return this.check(value,pass,'iterator');
+    }
+
+    asyncIterator(value){
+        const symbol=Symbol.asyncIterator;
+        const pass=value !== null && value !== undefined && protocolCheck(value,false,'next') && typeof symbol === 'symbol' && protocolCheck(value,symbol);
+        return this.check(value,pass,'async iterator');
+    }
+
+    iterable(value){
+        return this.check(value,protocolCheck(value,Symbol.iterator),'iterable');
+    }
+
+    asyncIterable(value){
+        return this.check(value,protocolCheck(value,Symbol.asyncIterator),'async iterable');
+    }
+
+    //errors
+    error(value){
+        return this.instanceCheck(value,Error);
+    }
+
+    aggregateError(value){
+        return this.globalInstanceCheck(value,'AggregateError');
+    }
+
+    evalError(value){
+        return this.instanceCheck(value,EvalError);
+    }
+
+    rangeError(value){
+        return this.instanceCheck(value,RangeError);
+    }
+
+    referenceError(value){
+        return this.instanceCheck(value,ReferenceError);
+    }
+
+    syntaxError(value){
+        return this.instanceCheck(value,SyntaxError);
+    }
+
+    typeError(value){
+        return this.instanceCheck(value,TypeError);
+    }
+
+    URIError(value){
+        return this.instanceCheck(value,URIError);
+    }
+
+    uriError(value){
+        return this.URIError(value);
+    }
+
+    suppressedError(value){
+        return this.globalInstanceCheck(value,'SuppressedError');
+    }
+
+    //typed arrays
+    typedArray(value){
+        return this.check(value,Boolean(typedArrayName(value)),'typed array');
+    }
+
+    arrayBufferView(value){
+        return this.check(value,arrayBufferViewCheck(value),'ArrayBuffer view');
+    }
+
+    bigInt64Array(value){
+        return this.check(value,typedArrayName(value) === 'BigInt64Array','BigInt64Array');
+    }
+
+    bigUint64Array(value){
+        return this.check(value,typedArrayName(value) === 'BigUint64Array','BigUint64Array');
+    }
+
+    float16Array(value){
+        return this.check(value,typedArrayName(value) === 'Float16Array','Float16Array');
+    }
+
+    float32Array(value){
+        return this.check(value,typedArrayName(value) === 'Float32Array','Float32Array');
+    }
+
+    float64Array(value){
+        return this.check(value,typedArrayName(value) === 'Float64Array','Float64Array');
+    }
+
+    int8Array(value){
+        return this.check(value,typedArrayName(value) === 'Int8Array','Int8Array');
+    }
+
+    int16Array(value){
+        return this.check(value,typedArrayName(value) === 'Int16Array','Int16Array');
+    }
+
+    int32Array(value){
+        return this.check(value,typedArrayName(value) === 'Int32Array','Int32Array');
+    }
+
+    uint8Array(value){
+        return this.check(value,typedArrayName(value) === 'Uint8Array','Uint8Array');
+    }
+
+    uint8ClampedArray(value){
+        return this.check(value,typedArrayName(value) === 'Uint8ClampedArray','Uint8ClampedArray');
+    }
+
+    uint16Array(value){
+        return this.check(value,typedArrayName(value) === 'Uint16Array','Uint16Array');
+    }
+
+    uint32Array(value){
+        return this.check(value,typedArrayName(value) === 'Uint32Array','Uint32Array');
+    }
+
+    //buffers
+    arrayBuffer(value){
+        return this.check(value,arrayBufferCheck(value),'ArrayBuffer');
+    }
+
+    sharedArrayBuffer(value){
+        return this.check(value,sharedArrayBufferCheck(value),'SharedArrayBuffer');
+    }
+
+    anyArrayBuffer(value){
+        return this.check(value,arrayBufferCheck(value) || sharedArrayBufferCheck(value),'ArrayBuffer or SharedArrayBuffer');
+    }
+
+    dataView(value){
+        return this.check(value,dataViewCheck(value),'DataView');
+    }
+
+    resizableArrayBuffer(value){
+        const pass=applyValue(value,arrayBufferResizableGetter) === true;
+        return this.check(value,pass,'resizable ArrayBuffer');
+    }
+
+    growableSharedArrayBuffer(value){
+        const pass=applyValue(value,sharedArrayBufferGrowableGetter) === true;
+        return this.check(value,pass,'growable SharedArrayBuffer');
+    }
+
+    detachedArrayBuffer(value){
+        if(!arrayBufferCheck(value)){
+            return this.check(value,false,'detached ArrayBuffer');
+        }
+
+        const prototype=globalThis.ArrayBuffer.prototype;
+        const descriptor=Object.getOwnPropertyDescriptor(prototype,'detached');
+        if(descriptor && typeof descriptor.get === 'function'){
+            return this.check(value,reflectApply(descriptor.get,value,noArguments) === true,'detached ArrayBuffer');
+        }
+
+        let detached=false;
+        try{
+            new DataView(value);
+        }catch(err){
+            detached=true;
+        }
+        return this.check(value,detached,'detached ArrayBuffer');
+    }
+
+    //Intl
+    intlDateTimeFormat(value){
+        const constructor=globalThis.Intl && globalThis.Intl.DateTimeFormat;
+        const pass=constructor && applyBrand(value,intlDateTimeFormatGetter);
+        return this.check(value,pass,'Intl.DateTimeFormat');
+    }
+
+    intlCollator(value){
+        const constructor=globalThis.Intl && globalThis.Intl.Collator;
+        const pass=constructor && applyBrand(value,intlCollatorCompareGetter);
+        return this.check(value,pass,'Intl.Collator');
+    }
+
+    intlDisplayNames(value){
+        const constructor=globalThis.Intl && globalThis.Intl.DisplayNames;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.DisplayNames');
+    }
+
+    intlListFormat(value){
+        const constructor=globalThis.Intl && globalThis.Intl.ListFormat;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.ListFormat');
+    }
+
+    intlLocale(value){
+        const constructor=globalThis.Intl && globalThis.Intl.Locale;
+        const pass=constructor && getterBrand(value,constructor.prototype,'baseName');
+        return this.check(value,pass,'Intl.Locale');
+    }
+
+    intlNumberFormat(value){
+        const constructor=globalThis.Intl && globalThis.Intl.NumberFormat;
+        const pass=constructor && applyBrand(value,intlNumberFormatGetter);
+        return this.check(value,pass,'Intl.NumberFormat');
+    }
+
+    intlPluralRules(value){
+        const constructor=globalThis.Intl && globalThis.Intl.PluralRules;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.PluralRules');
+    }
+
+    intlRelativeTimeFormat(value){
+        const constructor=globalThis.Intl && globalThis.Intl.RelativeTimeFormat;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.RelativeTimeFormat');
+    }
+
+    intlSegmenter(value){
+        const constructor=globalThis.Intl && globalThis.Intl.Segmenter;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.Segmenter');
+    }
+
+    intlSegments(value){
+        const constructor=globalThis.Intl && globalThis.Intl.Segmenter;
+        const pass=applyBrand(value,segmentsContainingFor(constructor),segmentProbeArguments);
+        return this.check(value,pass,'Intl Segments');
+    }
+
+    intlDurationFormat(value){
+        const constructor=globalThis.Intl && globalThis.Intl.DurationFormat;
+        const pass=constructor && methodBrand(value,constructor.prototype,'resolvedOptions');
+        return this.check(value,pass,'Intl.DurationFormat');
+    }
+
+    //garbage collection and resource management
+    finalizationRegistry(value){
+        const constructor=globalThis.FinalizationRegistry;
+        const pass=constructor && methodBrand(value,constructor.prototype,'unregister',brandProbeArguments);
+        return this.check(value,pass,'FinalizationRegistry');
+    }
+
+    weakRef(value){
+        const constructor=globalThis.WeakRef;
+        const pass=constructor && methodBrand(value,constructor.prototype,'deref');
+        return this.check(value,pass,'WeakRef');
+    }
+
+    disposable(value){
+        const symbol=Symbol.dispose;
+        return this.check(value,typeof symbol === 'symbol' && protocolCheck(value,symbol),'disposable');
+    }
+
+    asyncDisposable(value){
+        const symbol=Symbol.asyncDispose;
+        return this.check(value,typeof symbol === 'symbol' && protocolCheck(value,symbol),'async disposable');
+    }
+
+    disposableStack(value){
+        return this.globalInstanceCheck(value,'DisposableStack');
+    }
+
+    asyncDisposableStack(value){
+        return this.globalInstanceCheck(value,'AsyncDisposableStack');
+    }
+
+    //Temporal
+    temporalDuration(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'Duration');
+    }
+
+    temporalInstant(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'Instant');
+    }
+
+    temporalPlainDate(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'PlainDate');
+    }
+
+    temporalPlainDateTime(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'PlainDateTime');
+    }
+
+    temporalPlainMonthDay(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'PlainMonthDay');
+    }
+
+    temporalPlainTime(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'PlainTime');
+    }
+
+    temporalPlainYearMonth(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'PlainYearMonth');
+    }
+
+    temporalZonedDateTime(value){
+        return this.nestedInstanceCheck(value,globalThis.Temporal,'ZonedDateTime');
+    }
+
+    //URL and text
+    url(value){
+        return this.globalInstanceCheck(value,'URL');
+    }
+
+    urlSearchParams(value){
+        return this.globalInstanceCheck(value,'URLSearchParams');
+    }
+
+    urlPattern(value){
+        return this.globalInstanceCheck(value,'URLPattern');
+    }
+
+    textEncoder(value){
+        return this.globalInstanceCheck(value,'TextEncoder');
+    }
+
+    textDecoder(value){
+        return this.globalInstanceCheck(value,'TextDecoder');
+    }
+
+    textEncoderStream(value){
+        return this.globalInstanceCheck(value,'TextEncoderStream');
+    }
+
+    textDecoderStream(value){
+        return this.globalInstanceCheck(value,'TextDecoderStream');
+    }
+
+    //fetch and data
+    domException(value){
+        return this.globalInstanceCheck(value,'DOMException');
+    }
+
+    blob(value){
+        return this.globalInstanceCheck(value,'Blob');
+    }
+
+    file(value){
+        return this.globalInstanceCheck(value,'File');
+    }
+
+    formData(value){
+        return this.globalInstanceCheck(value,'FormData');
+    }
+
+    headers(value){
+        return this.globalInstanceCheck(value,'Headers');
+    }
+
+    request(value){
+        return this.globalInstanceCheck(value,'Request');
+    }
+
+    response(value){
+        return this.globalInstanceCheck(value,'Response');
+    }
+
+    //events and messaging
+    abortController(value){
+        return this.globalInstanceCheck(value,'AbortController');
+    }
+
+    abortSignal(value){
+        return this.globalInstanceCheck(value,'AbortSignal');
+    }
+
+    event(value){
+        return this.globalInstanceCheck(value,'Event');
+    }
+
+    eventTarget(value){
+        return this.globalInstanceCheck(value,'EventTarget');
+    }
+
+    customEvent(value){
+        return this.globalInstanceCheck(value,'CustomEvent');
+    }
+
+    messageEvent(value){
+        return this.globalInstanceCheck(value,'MessageEvent');
+    }
+
+    closeEvent(value){
+        return this.globalInstanceCheck(value,'CloseEvent');
+    }
+
+    errorEvent(value){
+        return this.globalInstanceCheck(value,'ErrorEvent');
+    }
+
+    broadcastChannel(value){
+        return this.globalInstanceCheck(value,'BroadcastChannel');
+    }
+
+    messageChannel(value){
+        return this.globalInstanceCheck(value,'MessageChannel');
+    }
+
+    messagePort(value){
+        return this.globalInstanceCheck(value,'MessagePort');
+    }
+
+    webSocket(value){
+        return this.globalInstanceCheck(value,'WebSocket');
+    }
+
+    eventSource(value){
+        return this.globalInstanceCheck(value,'EventSource');
+    }
+
+    navigator(value){
+        return this.globalValueCheck(value,'navigator');
+    }
+
+    storage(value){
+        return this.globalInstanceCheck(value,'Storage');
+    }
+
+    //streams
+    readableStream(value){
+        return this.globalInstanceCheck(value,'ReadableStream');
+    }
+
+    readableStreamDefaultReader(value){
+        return this.globalInstanceCheck(value,'ReadableStreamDefaultReader');
+    }
+
+    readableStreamBYOBReader(value){
+        return this.globalInstanceCheck(value,'ReadableStreamBYOBReader');
+    }
+
+    readableStreamDefaultController(value){
+        return this.globalInstanceCheck(value,'ReadableStreamDefaultController');
+    }
+
+    readableByteStreamController(value){
+        return this.globalInstanceCheck(value,'ReadableByteStreamController');
+    }
+
+    readableStreamBYOBRequest(value){
+        return this.globalInstanceCheck(value,'ReadableStreamBYOBRequest');
+    }
+
+    writableStream(value){
+        return this.globalInstanceCheck(value,'WritableStream');
+    }
+
+    writableStreamDefaultWriter(value){
+        return this.globalInstanceCheck(value,'WritableStreamDefaultWriter');
+    }
+
+    writableStreamDefaultController(value){
+        return this.globalInstanceCheck(value,'WritableStreamDefaultController');
+    }
+
+    transformStream(value){
+        return this.globalInstanceCheck(value,'TransformStream');
+    }
+
+    transformStreamDefaultController(value){
+        return this.globalInstanceCheck(value,'TransformStreamDefaultController');
+    }
+
+    byteLengthQueuingStrategy(value){
+        return this.globalInstanceCheck(value,'ByteLengthQueuingStrategy');
+    }
+
+    countQueuingStrategy(value){
+        return this.globalInstanceCheck(value,'CountQueuingStrategy');
+    }
+
+    compressionStream(value){
+        return this.globalInstanceCheck(value,'CompressionStream');
+    }
+
+    decompressionStream(value){
+        return this.globalInstanceCheck(value,'DecompressionStream');
+    }
+
+    //crypto and performance
+    crypto(value){
+        return this.globalValueCheck(value,'crypto');
+    }
+
+    subtleCrypto(value){
+        const crypto=globalThis.crypto;
+        return this.check(value,crypto && Object.is(value,crypto.subtle),'SubtleCrypto');
+    }
+
+    cryptoKey(value){
+        return this.globalInstanceCheck(value,'CryptoKey');
+    }
+
+    performance(value){
+        return this.globalValueCheck(value,'performance');
+    }
+
+    performanceEntry(value){
+        return this.globalInstanceCheck(value,'PerformanceEntry');
+    }
+
+    performanceMark(value){
+        const constructor=globalThis.PerformanceMark;
+        const pass=typeof constructor === 'function' ? instanceOf(value,constructor) : stringTagCheck(value,'PerformanceMark');
+        return this.check(value,pass,'PerformanceMark');
+    }
+
+    performanceMeasure(value){
+        const constructor=globalThis.PerformanceMeasure;
+        const pass=typeof constructor === 'function' ? instanceOf(value,constructor) : stringTagCheck(value,'PerformanceMeasure');
+        return this.check(value,pass,'PerformanceMeasure');
+    }
+
+    performanceObserver(value){
+        return this.globalInstanceCheck(value,'PerformanceObserver');
+    }
+
+    performanceObserverEntryList(value){
+        return this.globalInstanceCheck(value,'PerformanceObserverEntryList');
+    }
+
+    performanceResourceTiming(value){
+        return this.globalInstanceCheck(value,'PerformanceResourceTiming');
+    }
+
+    //WebAssembly
+    webAssemblyModule(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Module');
+    }
+
+    webAssemblyInstance(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Instance');
+    }
+
+    webAssemblyMemory(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Memory');
+    }
+
+    webAssemblyTable(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Table');
+    }
+
+    webAssemblyGlobal(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Global');
+    }
+
+    webAssemblyTag(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Tag');
+    }
+
+    webAssemblyException(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'Exception');
+    }
+
+    webAssemblyCompileError(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'CompileError');
+    }
+
+    webAssemblyLinkError(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'LinkError');
+    }
+
+    webAssemblyRuntimeError(value){
+        return this.nestedInstanceCheck(value,globalThis.WebAssembly,'RuntimeError');
+    }
+}
+
+const defaultThrow=Is.prototype.throw;
+
+export {Is as default,Is};