o = {a:2,b:3}

// Object.defineProperties()
Object.defineProperty(o,"b",{
	enumerable:false,
})
Object.defineProperty(o,"c",{
	enumerable:false,
})
Object.defineProperty(o,"d",{
	// enumerable:false,
})

zxc2 = Object.getOwnPropertyDescriptors (o)
// zxc2.a.enumerable=false



 
function okv(obj) {
	var k,v
	for ([k,v] of Object.entries(obj))
	// body...
	clog("!",k,v)
}

cnt = 0



prxt = {
	set:function(obj, prop, val,receiver){
		clog("prxt set ",obj, prop, val,receiver)
		return

		return Reflect.set(...arguments)
	},
	get:function(obj, prop,receiver){





		
		if (window.cnt){
		window.cnt+=1
		clog("prxt get ret",cnt,prop)
			return
		}
		window.cnt+=1
		clog("prxt get",obj, prop,receiver)
		// clog("prxt get",prop)
		// clog("prxt get")
		return

		return Reflect.get(...arguments)
	},
	// __prx:true,
	// rec:

}




delete obsObj
{

class obsObj {
	constructor(o){
		this.db = o
	}
	_pub_msg(m){
		clog("ixi PUB MSG",m)
	}
	_rec_msg(that,m){
		clog("ixi REC MSG2",m)
	}
	__noSuchMethod__(){
		clog("__lookupGetter__~",arguments)
	}
}
window.obsObj = obsObj
glob_mx.obsobj =new obsObj({})
glob_mx.obsobj2 =new obsObj({})
}


glob_mx.obsobj.__proto__ = new Proxy(glob_mx.obsobj.__proto__,prxt)

delete Magic
{

class Magic {
    constructor () {
        return new Proxy(this, this);
    }
    get (target, prop) {
        return this[prop] || 'MAGIC';
    }
}
window.Magic = Magic
glob_mx.magic =new Magic({})
glob_mx.magic2 =new Magic({})
// glob_mx.magic3 =new Magic({})
}
// __lookupGetter__

// function replacer(a0,a1,a2,a3,a4){
hdn = [
"__path_arr",
"__path",
"__dpth",
]

function replacer(key,val){
	// clog("REP",key,val,this)
	var v,k
	if (typeof(val) == "object" && val != null){
		// val._add="Z"
		v = Object.assign({},val)
		for (k of hdn){
			v[k] = val[k]
		}
		return v
	}
	return val
	// return a0
}


function jh(o){
	return JSON.parse(JSON.stringify(o, replacer))
}


s1 ={a:{b:{c:3}}}
// JSON.stringify({a:{b:{c:3}}}, replacer)
// JSON.stringify({}, replacer)
// JSON.stringify({a:{b:{c:3}}}, replacer)
// JSON.stringify({}, replacer[, space]])
// 
m = {}
m.m0 = {
	// k:["z2"]
}
m.m1 = {
	k:["z2","z3"]
}
m.m2 = {
	k:["z3"]
}
// m.


function isSubset(subset,superset){
    for (var elem of subset) {
        if (!superset.includes(elem)) {
            return false;
        }
    }
    return true;  
}

function isSubset_arr(subset,superset){
    for (var elem of subset) {
    	if (Array.isArray(elem)){

    		if (!new Set(elem).intersection(superset).size){
    			return false
    		}
    	} else if (!superset.includes(elem)) {
            return false;
        }
    }
    return true;  
}


function sym_info(o){
	var k,v 
	for ([k,v] of Object.entries(syms)){
		// clog(k,v)
		clog(k,o[v])
	}
}

function art(m,o){
	var k,v
	var r = 0
	var ret = {}
	var md =Object.getOwnPropertyDescriptors(m)

	for ([k,v] of Object.entries(md)){
		if (typeof(v.value) == "symbol"){
			r+=1
			ret[k]=v.value
		}


	// for ([k,v] in m){
		// case 
		clog(k,typeof(v.value),v.value,[v])
	}
	return {cnt:r,o:ret}
}
syms = art(Symbol).o

function match(mx,m,o){
	var k,v,k2,v2
	var r = 0
		// clog("@",mx,m,o)
	for ([k,v] of Object.entries(m || {})){
		v2 = o[k]
    // clog("M~",k,typeof(v),typeof(v2),v,v2)
		if (typeof(v) == "string" && typeof(v2) == "string") {
			r += !(v==v2)
		} else if (Array.isArray(v) && Array.isArray(v2)){
			r += !(isSubset_arr(v,v2))
		} else if (Array.isArray(v) && typeof(v2) == "string"){
      // r += !(isSubset_arr(v2,v))
      // r += !(isSubset_arr(v2,v))
      r += !v.includes(v2)
			// clog("!!!!!!!!!!!!!",v,v2,isSubset_arr(v2,v))
		} else if (Array.isArray(v2) && typeof(v) == "string"){
			r += !(v2.includes(v))
		}
		if (r){
			return !r
		}
	}
	return !r
}


// clog("m1,m2",match({},m.m1,m.m2))
// clog("m2,m1",match({},m.m2,m.m1))

// clog("m2,m0",match({},m.m2,m.m0))
// clog("m0,m2",match({},m.m0,m.m2))


a = ["A","B","C"]
a1 = ["A","B",,"D"]
a1[-1]="z"
a1["q"]="z2"
s2 = "str2"

r1 = [/a\d/,/b[a-z]\d/]

delete Str
{

class Str extends String {
	// constructor(o){
		// super(o)
	// }
	/*
		this.db = o
	}
	_pub_msg(m){
		clog("ixi PUB MSG",m)
	}
	_rec_msg(that,m){
		clog("ixi REC MSG2",m)
	}
	*/
}
window.Str = Str
}














function gpt(){
	try {
	clog("gx gpt",get_participants)
	clog("gx gpt2",get_participants())

	}	catch (err) {

	clog("gx gpt err:",err)
	}
}

gpt()



{

class QString extends String {
    isEmpty() {
        return this.length === 0;
    }
    concat(){
      return new QString(this + Array.prototype.join.call(arguments, ''));
    }
}

var testQStr1 = new QString("abc");
var testQStr2 = new QString("as easy as");
var testQStr3 = new QString("123");
var testStr3 = new String("123");

console.log(testQStr1,testQStr1 == "abc");
test1 = testQStr1.concat(testQStr2,testQStr3);
console.log(test1,test1=="abcas easy as123");




}










function switch_t(m,o){
	// var t 
	// var flags = {
	// 	leaf:"??",
	// 	prx:"??",
	// }
	// t = typeof(o)	
	// t=o
	// var s1 = t
	// var s2 = 2
	// var s0 = [s1,s2]
	// switch (...s0){
	switch (o[0],o[1]){
		case m[0][0],m[0][1]:
		clog("m0")
	break;
		case  m[1][0],m[1][1]:
		clog("m1")
		clog(m[1][0],m[1][1],":",o[0],o[1])
		// clog("~MX~","tlu")
	break;
	default:
		clog("default")

	}
}
o1 = []
m1 = [[],[]]
function wait(ms) {
  return new Promise(r => setTimeout(r, ms));
}
pfn1= async function(resolve, reject) {
	clog("RESV")
  // resolve('Success!');
	window.pfn1_cb = function(/*resolve, reject*/) {
  resolve('Success!');
	}
	await wait(3000)
	
	reject("TIMED_OUT")
}
pfn2=  function(resolve, reject) {
	clog("RESV")
  resolve({zzz:'Success!'});


}

prm ={}

// prm.resolve("zzz")
// promise1 = new Promise(pfn1);


promise1 = new Promise(pfnf(prm));

setTimeout(prm.reject,3000,"ST REJ")

	clog("and then")
promise1.then(function(value) {
  console.log(this,value,arguments);
  // expected output: "Success!"
});

promise1.then(function(value) {
  console.log("this,value,arguments");
  // expected output: "Success!"
});

promise1.catch(function(value) {
  console.log("REJECT",this,value,arguments);
  // expected output: "Success!"
});
	clog("and then...")


prm.resolve("11111zzz","zzzzzzz")