//global scoped fix, using polyfill idea
let forceLocal=(fn)=>{
  let before = Reflect.ownKeys(globalThis) //snapshot keys before
  fn() //run function
  let after = Reflect.ownKeys(globalThis) //snapshot keys after
  let globals = after.filter(e=>!before.includes(e)) //is in after but not before -> was added by fn
  globals.map(e=>{delete globalThis[e]}) //delete those added
}

let fn = () => {
  let scoped = 0 //is scoped
  whoops = 0 //is not scoped, forceLocal will handle it
}

forceLocal(fn)

console.log(whoops) //throws error, forceLocal cleaned it up

//scope inspector, useful for custom variable scoping
function inspectScope() {
  try {
    throw new Error(); //throws new error to extract stack generated
  } catch (e) {
    return e.stack //parses stack, details on how below
    .trim() //removed unnecessary "\n" so next step can split each stack element one by one
    .split("\n") //does the split
    .slice(1) //removes itself "inspectScope" from stack
    .map(line => 
      line
        .trim() //trims unnecessary spaces either side, due to indentation or otherwisw
        .replace(/^at\s+/, "") //removed repeated element "at ", so pure stack snippet is left
        .replace(/\s+/g, " ") //normalised spaces to always 1 space for next step
        .split(" ") //splits the spaces to get more detail on snippet "ErrorPlace (<input>:LineNumber)"
    )
  }
}

function test() {
  let b = 2;
  const c = 3;
  console.log(inspectScope())
}

test()

//Scope Extractor, extracts references to each function
let Scope = {
  calls:[],
  getCallStack:function(){
    this.calls = []
    let step = arguments.callee
    while(step){
      this.calls.push(step)
      step = step.caller
    }
  }
}

function Fn1(){
  Scope.getCallStack()
}

function Fn2() {
  Fn1();
}

function Fn3() {
  Fn2();
}

Fn3(1,2,3);

console.log(Scope.calls)
/*
[
  [Function: getCallStack],
  [Function: Fn1],
  [Function: Fn2],
  [Function: Fn3],
  [Function (anonymous)]
]
*/

//Observe GlobalThis through a proxy
;(()=>{
  let {Reflect, Object, Proxy, Date} = globalThis
  let active = false

  let snapshot = function (obj) {
    return Reflect.ownKeys(obj).reduce(function(o, k) {
      try { o[k] = obj[k] } catch(e) {}
      return o
    }, {})
  }
    
  let trap = Object.fromEntries(
    ["set","get"].map(op => [op, (...args) => {
      active = false
      try{
        console.log(args[1])
        return Reflect[op](...args)
      }finally{
        active = true
      }
    }])
  )

  let HANDLE = new Proxy({}, {
    get(_, t) {
      return (active ? trap[t] : void 0)
    }
  });

  Reflect.setPrototypeOf(globalThis, new Proxy(snapshot(globalThis), HANDLE))

  Reflect.ownKeys(globalThis).filter(k=>k !== "globalThis").forEach(k => {
    try { Reflect.deleteProperty(globalThis, k) } catch(e) {}
  });
  
  active = true
})();