edge.libx.js 0.0.1

package/src/helpers/jwt.ts

@@ -0,0 +1,287 @@
+import { libx } from 'libx.js/build/bundles/essentials.js';
+import { Base64 } from 'js-base64'
+import { network } from './EdgeNetwork.js';
+
+class JwtHelper {
+	private static cachedFirebasePublicKeys = <any>{};
+
+	private static base64urlEncode(str): string {
+		return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+	}
+
+	private static objectToBase64url(payload) {
+		return this.arrayBufferToBase64Url(new TextEncoder().encode(JSON.stringify(payload)));
+	}
+
+	private static arrayBufferToBase64Url(buffer) {
+		return btoa(String.fromCharCode(...new Uint8Array(buffer)))
+			.replace(/=/g, '')
+			.replace(/\+/g, '-')
+			.replace(/\//g, '_');
+	}
+
+	private static hexToBuffer(hex: string) {
+		const matches = hex.match(/[\da-f]{2}/gi) ?? []; // grab hex pairs
+		const { buffer } = new Uint8Array(matches.map((h) => parseInt(h, 16)));
+		return buffer;
+	}
+
+	private static base64UrlDecode = (str) => {
+		return libx.Buffer.from(str, 'base64').toString('utf-8');
+	};
+
+	private static async getGooglePublicKey(kid) {
+		if (this.cachedFirebasePublicKeys[kid]) return this.cachedFirebasePublicKeys[kid];
+		const result: any = await (
+			await fetch(
+				"https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com"
+				// 'https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com'
+			)
+		).json();
+
+		const res = result.keys.find((key) => key.kid === kid);
+		this.cachedFirebasePublicKeys[kid] = res;
+		return res;
+	}
+
+	public static async generateSignedJWT(serviceAccount: any, scope: string, options?: Partial<Options>) {
+		options = { ...new Options(), ...options };
+		const pem = serviceAccount.private_key.replace(/\n/g, '');
+
+		const pemHeader = '-----BEGIN PRIVATE KEY-----';
+		const pemFooter = '-----END PRIVATE KEY-----';
+
+		if (!pem.startsWith(pemHeader) || !pem.endsWith(pemFooter)) {
+			throw new Error('Invalid service account private key');
+		}
+
+		const pemContents = pem.substring(pemHeader.length, pem.length - pemFooter.length);
+		const buffer = Base64.toUint8Array(pemContents);
+		const algorithm = {
+			name: 'RSASSA-PKCS1-v1_5',
+			hash: {
+				name: 'SHA-256',
+			},
+		};
+		const extractable = false;
+		const privateKey = await crypto.subtle.importKey('pkcs8', buffer, algorithm, extractable, ["sign"]);
+
+		const header = Base64.encodeURI(
+			JSON.stringify({
+				alg: 'RS256',
+				typ: 'JWT',
+				kid: serviceAccount.private_key_id,
+			})
+		);
+
+		const iat = Math.floor(Date.now() / 1000);
+		const exp = iat + options.exp;
+		const payload = Base64.encodeURI(
+			JSON.stringify({
+				iss: serviceAccount.client_email,
+				sub: serviceAccount.client_email,
+				scope,
+				aud: options.aud,
+				exp,
+				iat,
+			})
+		);
+
+		const textEncoder = new TextEncoder();
+		const inputArrayBuffer = textEncoder.encode(`${header}.${payload}`);
+		const outputArrayBuffer = await crypto.subtle.sign({ name: 'RSASSA-PKCS1-v1_5' }, privateKey, inputArrayBuffer);
+		const signature = Base64.fromUint8Array(new Uint8Array(outputArrayBuffer), true);
+
+		return {
+			header,
+			payload,
+			signature
+		};
+	}
+
+	public static async generateToken(serviceAccount: any, scope: string, options?: Partial<Options>) {
+		const signed = await this.generateSignedJWT(serviceAccount, scope, options);
+		const token = `${signed.header}.${signed.payload}.${signed.signature}`;
+		return token;
+	}
+
+	public static async generateOAuth(serviceAccount: any, scope: string, options?: Partial<Options>) {
+		const token = await this.generateToken(serviceAccount, scope, options);
+		return await this.jwtToOAuth(token);
+	}
+
+	private static async jwtToOAuth(signedJwt: string) {
+		// Prepare the request to get an OAuth2 token
+		const tokenRequest = {
+			grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+			assertion: signedJwt
+		};
+
+		try {
+			/*
+			 // Make the request to Google's OAuth2 server
+			 const response = await axios.post('https://oauth2.googleapis.com/token', new URLSearchParams(tokenRequest).toString(), {
+				headers: {
+					'Content-Type': 'application/x-www-form-urlencoded'
+				}
+			});
+	
+			// Extract and return the access token
+			return response.data.access_token;
+			*/
+
+			// Make the request to Google's OAuth2 server
+			const response = await network.httpPostJson('https://oauth2.googleapis.com/token', tokenRequest);
+			// const response = await fetch('https://www.googleapis.com/oauth2/v4/token', {
+			// 	method: 'POST',
+			// 	headers: new Headers({
+			// 		'Content-Type': 'application/json',
+			// 	}),
+			// 	body: JSON.stringify(tokenRequest),
+			// });
+
+			// Extract and return the access token
+			const tmp = response as any;
+			// const tmp = await response.json<any>();
+			if (tmp.error) throw tmp;
+			return tmp.access_token;
+		} catch (error) {
+			console.error('Error fetching OAuth2 token:', error);
+			throw error;
+		}
+	}
+
+	public static async makeRequest(url: string, serviceAccountObj: Object, scope: string, payload: any, options = {
+		method: "POST",
+		exHeaders: {}
+	}) {
+		const token = await JwtHelper.generateOAuth(serviceAccountObj, scope);
+
+		libx.log.d('DBG: makeRequest: ', scope, token);
+		const bqResp = await fetch(url, {
+			method: options.method,
+			body: payload ? JSON.stringify(payload) : null,
+			headers: {
+				"content-type": "application/json;charset=UTF-8",
+				"Authorization": "Bearer " + token,
+				...options.exHeaders
+			}
+		});
+
+		// libx.log.i('DONE!', JSON.stringify(await this.gatherResponse(bqResp)))
+		return bqResp;
+	}
+
+	public static async verifyFirebaseToken(token, expectAud): Promise<IFirebaseTokenPayload> {
+		const dur = libx.Measurement.start();
+		const expectIss = `https://securetoken.google.com/${expectAud}`;
+		const tokenParts = token.split('.');
+		const header = JSON.parse(atob(tokenParts[0]));
+		const key = await this.getGooglePublicKey(header.kid);
+		const payload = await this.verifyToken(key, token, expectAud, expectIss) as IFirebaseTokenPayload;
+
+		libx.log.d(`verifyFirebaseToken: dur: ${dur.peek()}ms`);
+		return payload;
+	}
+
+	public static async verifyToken(publicKey, token, expectAud, expectIss, checkExpiry = true): Promise<IJwtTokenPayload> {
+		try {
+			// const payload = this.decodeToken(token);
+			const payload2 = this.decodeToken(token);
+
+			if (expectAud && payload2.payload.aud != expectAud) {
+				throw 'verifyToken: mismatched aud!';
+			}
+			if (expectIss && payload2.payload.iss != expectIss) {
+				throw 'verifyToken: mismatched iss!';
+			}
+
+			const tokenParts = token.split('.');
+			const alg = { name: 'RSASSA-PKCS1-v1_5', hash: { name: 'SHA-256' } };
+			const key = await crypto.subtle.importKey('jwk', publicKey, alg, false, ['verify']);
+			const isVerified = await crypto.subtle.verify(alg, key, this.parseBase64Url(tokenParts[2]), this.utf8ToUint8Array(`${tokenParts[0]}.${tokenParts[1]}`));
+
+			if (checkExpiry && payload2.payload.exp <= Math.floor(Date.now() / 1000)) {
+				throw 'verifyToken: expired!';
+			}
+
+			if (isVerified == false) {
+				throw 'verifyToken: invalid token!';
+			}
+
+			return payload2.payload;
+		} catch (error) {
+			libx.log.e('Error verifying token:', error);
+			throw error;
+		}
+	}
+
+	public static decodeToken(idToken) {
+		const [header, payload, signature] = idToken.split('.').map(part => this.base64UrlDecode(part));
+		return {
+			rawHeader: header,
+			header: JSON.parse(header),
+			payload: JSON.parse(payload),
+			rawPayload: payload,
+			signature: signature,
+		};
+	};
+
+	private static parseBase64Url(url) {
+		return new Uint8Array(Array.prototype.map.call(atob(url.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '')), c => c.charCodeAt(0)))
+	}
+
+	private static utf8ToUint8Array(str) {
+		return this.parseBase64Url(btoa(unescape(encodeURIComponent(str))))
+	}
+
+	private static decodeToken_2(token) {
+		let raw = token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/');
+		switch (raw.length % 4) {
+			case 0:
+				break
+			case 2:
+				raw += '=='
+				break
+			case 3:
+				raw += '='
+				break
+			default:
+				throw new Error('Illegal base64url string!')
+		}
+
+		try {
+			return JSON.parse(decodeURIComponent(escape(atob(raw))))
+		} catch {
+			return null
+		}
+	}
+}
+
+class Options {
+	aud = 'https://oauth2.googleapis.com/token';
+	exp = 3600;
+}
+
+interface IJwtTokenPayload {
+	name: string;
+	picture: string;
+	iss: string;
+	aud: string;
+	auth_time: number,
+	user_id: string;
+	sub: string;
+	iat: number,
+	exp: number,
+	email: string;
+	email_verified: true,
+}
+
+export interface IFirebaseTokenPayload extends IJwtTokenPayload {
+	firebase: {
+		identities: any,
+		sign_in_provider: string;
+	}
+}
+
+export { JwtHelper };

package/src/helpers/localServer.ts

@@ -0,0 +1,75 @@
+import { createServerAdapter } from '@whatwg-node/server';
+import 'isomorphic-fetch';
+import { IRequest, Router, error, json } from 'itty-router';
+import express from 'express';
+import { getExpress } from './getExpress';
+// import { router, server } from '../v5';
+import fs from 'fs';
+import { log, LogLevel } from 'libx.js/build/modules/log';
+import { libx } from 'libx.js/build/bundles/node.essentials';
+import path from 'path';
+
+log.isDebug = true;
+log.filterLevel = LogLevel.All;
+
+const envFile = '.env'; //'.dev.vars'
+
+const entryPoints = libx.node.args._;
+
+const { app } = getExpress();
+
+// node-wrangler bridge:
+// global.crypto = require('crypto');
+// global.TransformStream = require('web-streams-polyfill').TransformStream;
+
+function getEnvVars() {
+	const envFilePath = path.join(process.cwd(), envFile);
+	if (!fs.existsSync(envFilePath)) return null;
+	const content = fs.readFileSync(envFilePath)?.toString();
+	const ret = {};
+	for (let line of content.split('\n')) {
+		const parts = line.split('=');
+		if (parts[0].trim().startsWith('#') || parts[1] == null) continue;
+		ret[parts[0].trim()] = parts[1].replace(/\s*[\"\'](.+)[\"\']\s*/gi, '$1');
+	}
+	return ret;
+}
+
+libx.node.catchErrors((err) => {
+	console.error('!!!!!! ERROR: ', err);
+}, false);
+
+
+
+// only lunch manual local server if using 'dev' command
+if (['debug', 'debug:watch'].indexOf(process.env.npm_lifecycle_event) !== -1) {
+	const env = getEnvVars() ?? { a: 1 };
+
+	for (let entryPoint of entryPoints) {
+		const dir = process.cwd(); // process.argv[1]
+		const { handler, prefix } = require(`${dir}/${entryPoint}`);
+		app.use(
+			prefix ?? '/api',
+			createServerAdapter((request, env) =>
+				handler(<IRequest>request, env))
+		);
+	}
+
+	// app.use(
+	// 	'/v5-n',
+	// 	createServerAdapter((request, env) =>
+	// 		handler_node(<IRequest>request, env))
+	// 		// handlerRedirect(<IRequest>request, env))
+	// );
+
+	const port = 8080;
+	try {
+		app.listen(port, () => {
+			console.log(`Server listening on http://0.0.0.0:${port}`);
+		});
+	} catch (err) {
+		console.warn(`LOCAL: Failed to start local server on port: ${port}`);
+	}
+}
+
+// export default server; //routes.fetch;

package/src/helpers/require.ts

@@ -0,0 +1,331 @@
+// @ts-nocheck
+
+const reqSetup = (function () {
+    // var require = libx.browser.require;
+	
+    var mod = {};
+
+    (function (load) {
+        'use strict';
+        var RequireError = function (message, fileName, lineNumber) {
+            this.name = 'RequireError';
+            this.message = message;
+        };
+        RequireError.prototype = Object.create(Error.prototype);
+
+        // NOTE Mozilla still sets the wrong fileName porperty for errors that occur
+        //      inside an eval call (even with sourceURL). However, the stack
+        //      contains the correct source, so it can be used to re-threw the error
+        //      with the correct fileName property.
+        // NOTE Re-threwing a new error object will mess up the stack trace and the
+        //      column number.
+        if (typeof new Error().fileName == 'string') {
+            self.addEventListener(
+                'error',
+                function (evt) {
+                    if (evt.error instanceof Error) {
+                        if (pwd[0]) {
+                            evt.preventDefault();
+                            throw new evt.error.constructor(evt.error.message, pwd[0].uri, evt.error.lineNumber);
+                        } else {
+                            var m = evt.error.stack.match(/^[^\n@]*@([^\n]+):\d+:\d+/);
+                            if (m === null) {
+                                console.warn('libx.browser.require: unable to read file name from stack');
+                            } else if (evt.error.fileName != m[1]) {
+                                evt.preventDefault();
+                                throw new evt.error.constructor(evt.error.message, m[1], evt.error.lineNumber);
+                            }
+                        }
+                    }
+                },
+                false
+            );
+        }
+
+        // INFO Current module descriptors
+        //      pwd[0] contains the descriptor of the currently loaded module,
+        //      pwd[1] contains the descriptor its parent module and so on.
+
+        var pwd = Array();
+
+        // INFO Path parser
+        // NOTE Older browsers don't support the URL interface, therefore we use an
+        //      anchor element as parser in that case. Thes breaks web worker support,
+        //      but we don't care since these browser also don't support web workers.
+
+        var parser = URL ? new URL(location.href) : document.createElement('A');
+
+        // INFO Module cache
+        // NOTE Contains getter functions for the exports objects of all the loaded
+        //      modules. The getter for the module 'mymod' is name '$name' to prevent
+        //      collisions with predefined object properties (see note below).
+        //      As long as a module has not been loaded the getter is either undefined
+        //      or contains the module code as a function (in case the module has been
+        //      pre-loaded in a bundle).
+        // NOTE IE8 supports defineProperty only for DOM objects, therfore we use a
+        //      HTMLDivElement as cache in that case. This breaks web worker support,
+        //      but we don't care since IE8 has no web workers at all.
+
+        try {
+            var cache = new Object();
+            Object.defineProperty(cache, 'foo', { value: 'bar', configurable: true });
+            delete cache.foo;
+        } catch (e) {
+            console.warn('Falling back to DOM workaround for defineProperty: ' + e);
+            cache = document.createElement('DIV');
+        }
+
+        // INFO Send lock
+        // NOTE Sending the request causes the event loop to continue. Therefore
+        //      pending AJAX load events for the same url might be executed before
+        //      the synchronous onLoad is called. This should be no problem, but in
+        //      Chrome the responseText of the sneaked in load events will be empty.
+        //      Therefore we have to lock the loading while executing send().
+
+        var lock = new Object();
+
+        var requirePath = mod && mod.requirePath !== undefined ? mod.requirePath.slice(0) : ['./'];
+        var requireCompiler = mod && mod.requireCompiler !== undefined ? mod.requireCompiler : null;
+
+        // NOTE Parse module root paths
+        var base = [location.origin, location.href.substr(0, location.href.lastIndexOf('/') + 1)];
+        for (var i = 0; i < requirePath.length; i++) {
+            parser.href = (requirePath[i][0] == '.' ? base[1] : base[0]) + requirePath[i];
+            requirePath[i] = parser.href;
+        }
+
+        // NOTE Add preloaded modules to cache
+        for (var id in mod && mod.requirePreloaded) cache['$' + resolve(id).id] = mod.requirePreloaded[id].toString();
+
+        // NOTE Add module overrides to cache
+        for (var id in mod && mod.requireOverrides) cache['$' + resolve(id).id] = mod.requireOverrides[id];
+
+        // INFO Module getter
+        //      Takes a module identifier, resolves it and gets the module code via an
+        //      AJAX request from the module URI. If this was successful the code and
+        //      some environment variables are passed to the load function. The return
+        //      value is the module's `exports` object. If the cache already
+        //      contains an object for the module id, this object is returned directly.
+        // NOTE If a callback function has been passed, the AJAX request is asynchronous
+        //      and the module exports are passed to the callback function after the
+        //      module has been loaded.
+
+        mod = async function (identifier, callback, compiler) {
+            return new Promise((resolvePromise, rejectPromise) => {
+                if (identifier instanceof Array) {
+                    var modules = new Array();
+                    var modcount = identifier.length;
+                    for (var index = 0; index < identifier.length; index++) {
+                        (function (id, i) {
+                            modules.push(
+                                mod(
+                                    id,
+                                    callback &&
+                                        function (mod) {
+                                            modules[i] = mod;
+                                            --modcount == 0 && callback(modules);
+                                        },
+                                    compiler
+                                )
+                            );
+                        })(identifier[index], index);
+                    }
+                    return modules;
+                }
+
+                compiler = compiler !== undefined ? compiler : requireCompiler;
+                var descriptor = resolve(identifier);
+                var cacheid = '$' + descriptor.id;
+
+                if (cache[cacheid]) {
+                    if (typeof cache[cacheid] === 'string') load(descriptor, cache, pwd, cache[cacheid]);
+                    // NOTE The callback should always be called asynchronously to ensure
+                    //      that a cached call won't differ from an uncached one.
+                    callback &&
+                        setTimeout(function () {
+                            callback(cache[cacheid]);
+                        }, 0);
+                    return resolvePromise(cache[cacheid]);
+                }
+
+                var request = new XMLHttpRequest();
+
+                // NOTE IE8 doesn't support the onload event, therefore we use
+                //      onreadystatechange as a fallback here. However, onreadystatechange
+                //      shouldn't be used for all browsers, since at least mobile Safari
+                //      seems to have an issue where onreadystatechange is called twice for
+                //      readyState 4.
+                callback && (request[request.onload === null ? 'onload' : 'onreadystatechange'] = onLoad);
+                request.addEventListener('load', onLoad);
+                request.open('GET', descriptor.uri, true); //!!callback);
+
+                try {
+                    // request.setRequestHeader('Origin', window.location.hostname);
+                    // request.setRequestHeader('Access-Control-Allow-Origin', '*');
+                    // request.setRequestHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, PUT, DELETE, OPTIONS');
+                    // request.setRequestHeader('Access-Control-Allow-Headers', 'Origin, Content-Type, X-Auth-Token');
+                } catch (ex) {
+                    console.warn('libx.require: Error setting CORS headers. ', ex);
+                }
+
+                lock[cacheid] = lock[cacheid]++ || 1;
+                request.send();
+                !callback && onLoad();
+
+                function onLoad() {
+                    try {
+                        if (request.readyState != 4) return;
+                        if (request.status != 200)
+                            new RequireError('unable to load ' + descriptor.id + ' (' + request.status + ' ' + request.statusText + ')');
+                        if (request.status == 200) lock[cacheid]--;
+                        if (lock[cacheid]) {
+                            console.warn('module locked: ' + descriptor.id);
+                            if (lock[cacheid] <= 5) return;
+                            callback && setTimeout(onLoad, 0);
+                            return;
+                        }
+                        if (!cache[cacheid]) {
+                            var source = compiler ? compiler(request.responseText) : request.responseText;
+                            load(descriptor, cache, pwd, source, typeof callback == 'boolean');
+                        }
+
+                        !callback && onLoad();
+
+                        callback && callback(cache[cacheid]);
+                        resolvePromise(cache[cacheid]);
+                    } catch (err) {
+                        rejectPromise(err);
+                    }
+                }
+            });
+        };
+
+        // INFO Module resolver
+        //      Takes a module identifier and resolves it to a module id and URI. Both
+        //      values are returned as a module descriptor, which can be passed to
+        //      `fetch` to load a module.
+
+        function fixSlash(url) {
+            var isDoubleSlash = url.startsWith('//');
+            var ret = url.replace(/[\/]+/g, '/').replace(':/', '://'); //.replace(/\/\//g, '/').replace(':/', '://');
+            if (isDoubleSlash) ret = ret.replace(/^\//, '//');
+            return ret;
+        }
+
+        function resolve(identifier) {
+            if (
+                identifier.indexOf('http://') == 0 ||
+                identifier.indexOf('https://') == 0 ||
+                identifier.indexOf('//') == 0 ||
+                identifier.indexOf('://') != -1
+            )
+                return { id: identifier, uri: fixSlash(identifier) };
+
+            if (identifier.indexOf('/') == 0) {
+                var root = requirePath[0].substr(0, requirePath[0].indexOf('/', requirePath[0].indexOf('://') + 3));
+                return { id: identifier, uri: fixSlash(root + '/' + identifier) };
+            }
+
+            return { id: identifier, uri: fixSlash(identifier) };
+
+            // NOTE Matches [1]:[..]/[path/to/][file][.js]
+            var m = identifier.match(/^(?:([^:\/]+):)?(\.\.?)?\/?((?:.*\/)?)([^\.]+)?(\..*)?$/);
+            // NOTE Matches [1]:[/path/to/]file.js
+            var p = (pwd[0] ? pwd[0].id : '').match(/^(?:([^:\/]+):)?(.*\/|)[^\/]*$/);
+            var root = m[2] ? requirePath[p[1] ? parseInt(p[1]) : 0] : requirePath[m[1] ? parseInt(m[1]) : 0];
+            parser.href = (m[2] ? root + p[2] + m[2] + '/' : root) + m[3] + (m[4] ? m[4] : 'index');
+            var uri = parser.href + (m[5] ? m[5] : '.js');
+            if (uri.substr(0, root.length) != root) throw new RequireError('Relative identifier outside of module root');
+            var id = (m[1] ? m[1] + ':' : '0:') + parser.href.substr(root.length);
+
+            return { id: id, uri: fixSlash(uri) };
+        }
+
+        // INFO Exporting require to global scope
+
+        if (mod !== undefined) {
+            //throw new RequireError('\'require\' already defined in global scope');
+            //console.warn("'\'require\' already defined in global scope'");
+            return;
+        }
+
+        try {
+            Object.defineProperty('require', { value: mod });
+            Object.defineProperty(mod, 'resolve', { value: resolve });
+            Object.defineProperty(mod, 'path', {
+                get: function () {
+                    return requirePath.slice(0);
+                },
+            });
+        } catch (e) {
+            // NOTE IE8 can't use defineProperty on non-DOM objects, so we have to fall
+            //      back to unsave property assignments in this case.
+            mod.resolve = resolve;
+            mod.path = requirePath.slice(0);
+        }
+    })(
+        // INFO Module loader
+        //      Takes the module descriptor, the global variables and the module code,
+        //      sets up the module envirinment, defines the module getter in the cache
+        //      and evaluates the module code. If module is a bundle the code of the
+        //      pre-loaded modules will be stored in the cache afterwards.
+        // NOTE This functions is defined as an anonymous function, which is passed as
+        //      a parameter to the closure above to provide a clean environment (only
+        //      global variables, module and exports) for the loaded module. This is
+        //      also the reason why `source`, `pwd` & `cache` are not named parameters.
+        // NOTE If we would strict use mode here, the evaluated code would be forced to be
+        //      in strict mode, too.
+
+        function (/*load*/ module /*, cache, pwd, source, isNotModule*/) {
+            var global = self;
+            var exports = new Object();
+            Object.defineProperty(module, 'exports', {
+                get: function () {
+                    return exports;
+                },
+                set: function (e) {
+                    exports = e;
+                },
+            });
+            arguments[2].unshift(module);
+            Object.defineProperty(arguments[1], '$' + module.id, {
+                get: function () {
+                    return exports;
+                },
+            });
+
+            var content = arguments[3];
+            var isNotModule = arguments[4];
+
+            if (isNotModule === true) {
+                eval(content);
+            } else {
+                var extra = 'var __moduleUri = "' + module.uri + '";\n';
+                if (!module.uri.endsWith('.js')) {
+                    content = 'module.exports = ' + content;
+                }
+                var script = 'function(){\n' + extra + content + '\n}';
+                let wrapper = '(' + script + ')();\n//# sourceURL=' + module.uri;
+
+                eval(wrapper);
+            }
+
+            // var script = '(function(__moduleUri){\n ('+arguments[3]+')}(); \n'
+            // arguments[3] = '(' + extra + script+')("' + module.uri + '");\nsourceURL="'+module.uri+'"';
+
+            // load(descriptor, cache, pwd, 'function(){\n'+source+'\n}');
+            // arguments[3] = '('+arguments[3]+')();\n//# sourceURL='+module.uri;
+
+            // if (typeof Function != "undefined") new Function(arguments[3]);
+            // else
+            // NOTE Store module code in the cache if the loaded file is a bundle
+            if (typeof module.id !== 'string') for (id in module) arguments[1]['$' + mod.resolve(id).id] = module[id].toString();
+            arguments[2].shift();
+        }
+    );
+
+    return mod;
+})();
+
+
+export const require = reqSetup();