process_ = process;
require_ = require;
delete Buffer;
// delete process;
delete require;
delete global;
delete module;
delete exports;
delete __filename;
delete __dirname;
delete SharedArrayBuffer;

AsObj = {
    // print: console.log,
    print: function () { },
    // print_:console.log,
}

no_print = ['Boolean','String','parseFloat','Array','Object','prepareStackTrace_'];
function watch(object, WatchName) {
    const handler = {
      get(target, property, receiver) {
        if (
          property !== 'isNaN' &&
          property !== 'encodeURI' &&
          property !== "Uint8Array" &&
          property !== 'undefined' &&
          property !== 'JSON' &&
          property !== 'Number' &&
          !no_print.includes(property) &&
            property !== Symbol.for('nodejs.util.inspect.custom') &&
            typeof property !== 'symbol'
        ) {

            if (property === 'global') {
              return undefined;
            }
            if (property === 'Buffer') {
              return undefined;
            }
            if (property === 'process') {
                return undefined;
            }
            if (WatchName === 'config_data') {
                debugger
            }
            if (WatchName.indexOf('.prototype') != -1 && target[property] != undefined) {
                return Reflect.get(target, property, receiver);
            }

            AsObj.print(
            "方法:", "get", 
            "对象:", WatchName, 
            "属性:", property, 
            "属性类型:", typeof property, 
            "属性值:", typeof target[property] == 'object' ? "object" : target[property], 
            "属性值类型:", typeof target[property]
          );
        }
        
        if (WatchName === 'top') {
            return window;
        }
            
        return Reflect.get(target, property, receiver);
      },
  
    set(target, property, value, receiver) {
        if (WatchName.indexOf('.prototype') != -1 && value != undefined) {
            return Reflect.set(target, property, value, receiver);
        }
        AsObj.print(
          "方法:", "set", 
          "对象:", WatchName, 
          "属性:", property, 
          "属性类型:", typeof property, 
          "属性值:", typeof value == 'object' ? "object" : value,
          "属性值类型:", typeof target[property]
        );
        return Reflect.set(target, property, value, receiver);
      },
      // in操作 检测 
    has(target, property) {
        AsObj.print(
          "代理对象:", WatchName,
          "方法:", "has",
          "检查属性:", property,
          "结果:", typeof target[property] == 'object' ? "object" : target[property], 
        );
        return Reflect.has(target, property);
      },
      // Object.key 检测 	
    ownKeys(target) {
        AsObj.print(
          "方法:", "ownKeys",
          "对象:", target+''
        );
        return Reflect.ownKeys(target);
      }
    };
  
    return new Proxy(object, handler);
}
// function watch(object, WatchName) {
//     return object
// }

// 保护函数，toString检测
const safeFunction = function safeFunction(func) {
    //处理安全函数
    Function.prototype.$call = Function.prototype.call;
    const $toString = Function.toString;
    const myFunction_toString_symbol = Symbol('('.concat('', ')'));
   
    const myToString = function myToString() {
      return typeof this === 'function' && this[myFunction_toString_symbol] || $toString.$call(this);
    }
   
    const set_native = function set_native(func, key, value) {
      Object.defineProperty(func, key, {
        "enumerable": false,
        "configurable": true,
        "writable": true,
        "value": value
      });
    }
   
    delete Function.prototype['toString'];
    set_native(Function.prototype, "toString", myToString);
    set_native(Function.prototype.toString, myFunction_toString_symbol, "function toString() { [native code] }");
   
    const safe_Function = function safe_Function(func) {
      set_native(func, myFunction_toString_symbol, "function" + (func.name ? " " + func.name : "") + "() { [native code] }");
    }
   
    return safe_Function(func)
}

//创建函数，并代理上
const makeFunction = function makeFunction(name) {
    v_log = AsObj.print;
    // 使用 Function 保留函数名
    func = new Function("v_log", `
          return function ${name}() {
              v_log('函数${name}传参-->', arguments);
          };
      `)(v_log); // 传递 v_log 到动态函数
   
    safeFunction(func);
    func = watch(func,`${name}`);
    func.prototype = watch(func.prototype, `${name}.prototype`);
    return func;
}

!(function () {
    "use strict";
    const $toString = Function.toString;
    const myFunction_toString_symbol = Symbol('('.concat('', ')_', (Math.random() + '').toString(36)));
    const mytoString = function () {
        return typeof this == 'function' && this[myFunction_toString_symbol] || $toString.call(this);
    };

    function set_native(func, key, value) {
        Object.defineProperty(func, key, {
            "enumerable": false,
            "configurable": true,
            "writable": true,
            "value": value
        })
    };
    delete Function.prototype['toString'];
    set_native(Function.prototype, "toString", mytoString);
    set_native(Function.prototype.toString, myFunction_toString_symbol, "function toString() { [native code] }");
    this.func_set_native = function (func) {
        set_native(func, myFunction_toString_symbol, `function ${myFunction_toString_symbol, func.name || ''}() { [native code] }`)
    }
}).call(globalThis);

// 重写全局对象原型链
function setTostringAndstringTag(obj) {
    Object.defineProperties(obj.prototype, {
        [Symbol.toStringTag]: {
            configurable: true,
            value: obj.name
        }
    });
    safeFunction(obj);
};

// 创建标签原型
function createTagProto(propObj,portotypeObj) {
    let res = propObj + ' = ' + 'function ' + propObj + '() { throw new TypeError("Illegal constructor"); };\n';
    res += 'setTostringAndstringTag(' + propObj + ',null);\n';
    if (portotypeObj) {
        for (let key in portotypeObj) {
            res += propObj + '.prototype.' + portotypeObj[key] + '= function ' + portotypeObj[key] + '() {AsObj.print("'+propObj+'.prototype.' + portotypeObj[key] + '原型方法（需在实例对象上补该方法）::",arguments)};\n';
            res += 'globalThis.func_set_native(' + propObj + '.prototype.' + portotypeObj[key] + ');\n';
        }
    }
    eval(res);
}

Object.defineProperties(globalThis, {
    [Symbol.toStringTag]: {
        configurable: true,
        value: 'Window'
    }
});

for (let key in globalThis) {
    if (typeof globalThis[key] === 'function') {
        safeFunction(globalThis[key])
    }
}
for (let key in console) {
    if (typeof console[key] === 'function') {
        safeFunction(console[key])
    }
}

createTagProto('EventTarget',['addEventListener']);
createTagProto('WindowProperties');
createTagProto('Window');

window = globalThis;
window.__proto__ = Window.prototype;
window.__proto__.__proto__ = WindowProperties.prototype;
window.__proto__.__proto__.__proto__ = EventTarget.prototype;
Window.__proto__ = EventTarget;

Object.defineProperty(window, 'WindowProperties', {
    get: function () {
        return undefined;
    }
})

function randoms(min, max) {
    return Math.floor(Math.random() * (max - min + 1) + min)
}

function getRandomValues(buf) {
    var min = 0,
        max = 255;
    if (buf instanceof Uint16Array) {
        max = 65535;
    } else if (buf instanceof Uint32Array) {
        max = 4294967295;
    }
    for (var element in buf) {
        buf[element] = randoms(min, max);
    }
    return buf;
}


self = window.self = window;
frames = window.frames = window;
top = window.top = window;
parent = window.parent = window;
global = window.global = window;

Object.defineProperty(window, "global", {
    configurable:false,
    enumerable: true,
    set: undefined,
    get: function global(){
        return window
    }
})
Object.defineProperty(window, "top", {
    configurable:false,
    enumerable: true,
    set: undefined,
    get: function top(){
        return window
    }
})
Object.defineProperty(window, "self", {
    configurable:false,
    enumerable: true,
    set: undefined,
    get: function self(){
        return window
    }
})
Object.defineProperty(window, "parent", {
    configurable:false,
    enumerable: true,
    set: undefined,
    get: function parent(){
        return window
    }
})
Object.defineProperty(window, "frames", {
    configurable:false,
    enumerable: true,
    set: undefined,
    get: function frames(){
        return window
    }
})

innerWidth = 1536
innerHeight = 715
outerWidth = 1536
outerHeight = 824
devicePixelRatio = 1.25;
screenLeft = 0;
screenX = 0;
screenTop = 0;
screenY = 0;
opener = null;
isSecureContext = true;
crypto = {
    getRandomValues:getRandomValues
};

createTagProto('DOMStringMap')
createTagProto('HTMLHeadElement',['insertBefore','removeChild'])
createTagProto('HTMLBodyElement',['addEventListener','appendChild','removeChild'])
createTagProto('HTMLHtmlElement',['getAttribute'])
createTagProto('HTMLDocument')
createTagProto('Document',['browsingTopics','appendChild','querySelector','evaluate','querySelectorAll','removeChild','requestStorageAccess','requestStorageAccessFor','hasStorageAccess','getElementsByTagName','hasPrivateToken','createElement','hasRedemptionRecord','hasFocus'])
createTagProto('Node')
document = {};
document.__proto__ = HTMLDocument.prototype;
document.__proto__.__proto__ = Document.prototype;
document.__proto__.__proto__.__proto__ = Node.prototype;
document.__proto__.__proto__.__proto__.__proto__ = EventTarget.prototype;
HTMLDocument.__proto__ = Document;
HTMLDocument.__proto__.__proto__ = Node;
HTMLDocument.__proto__.__proto__.__proto__ = EventTarget;
Document.__proto__ = Node;
Document.__proto__.__proto__ = EventTarget;
Node.__proto__ = EventTarget;

createTagProto('Plugin');
createTagProto('PluginArray');
plugins0 = {
    name: 'PDF Viewer',
    filename: 'internal-pdf-viewer',
    description:'Portable Document Format',
    length: 2,
    '0': {
        type: 'application/pdf',
    },
    '1':{
        type:'text/pdf'
    }
}
plugins0['0'].enabledPlugin = plugins0;
plugins0['1'].enabledPlugin = plugins0;
plugins1 = {
    name: 'Chrome PDF Viewer',
    filename: 'internal-pdf-viewer',
    description:'Portable Document Format',
    length: 2,
    '0': {
        type:'application/pdf'
    },
    '1': {
        type:'text/pdf'
    }
}
plugins1['0'].enabledPlugin = plugins1;
plugins1['1'].enabledPlugin = plugins1;
plugins2 = {
    name: 'Chromium PDF Viewer',
    filename: 'internal-pdf-viewer',
    description:'Portable Document Format',
    length: 2,
    '0': {
        type:'application/pdf'
    },
    '1': {
        type:'text/pdf'
    }
}
plugins2['0'].enabledPlugin = plugins2;
plugins2['1'].enabledPlugin = plugins2;
plugins3 = {
    name: 'Microsoft Edge PDF Viewer',
    filename: 'internal-pdf-viewer',
    description:'Portable Document Format',
    length: 2,
    '0':{
        type:'application/pdf'
    },
    '1': {
        type:'text/pdf'
    }
}
plugins3['0'].enabledPlugin = plugins3;
plugins3['1'].enabledPlugin = plugins3;
plugins4 = {
    name: 'WebKit built-in PDF',
    filename: 'internal-pdf-viewer',
    description:'Portable Document Format',
    length: 2,
    '0': {
        type:'application/pdf'
    },
    '1':{
        type:'text/pdf'
    }
}
plugins4['0'].enabledPlugin = plugins4;
plugins4['1'].enabledPlugin = plugins4;
plugins = {
    length: 5,
    '0': plugins0,
    '1': plugins1,
    '2': plugins2,
    '3': plugins3,
    '4': plugins4,
    namedItem : function (name) {
        AsObj.print('Plugin-namedItem:', name)
    },
    item: function (index) {
        AsObj.print('Plugin-item:', index)
        return watch(plugins0,'item-'+index);
    },
    refresh: function () {
        AsObj.print('Plugin-refresh:',arguments)
    },
}
plugins.__proto__ = PluginArray.prototype;

MimeTypeArray = function MimeTypeArray() {
    this.length = 2;
    this['0'] = {
        suffixes: 'pdf',
        type: 'application/pdf',
        description:"Portable Document Format",
        enabledPlugin: plugins0
    };
    this['1'] = {
        suffixes: 'pdf',
        type: 'text/pdf',
        description:"Portable Document Format",
        enabledPlugin: plugins0
    };
};
MimeTypeArray.prototype.toString = function () { return '[object MimeTypeArray]'; }
MimeTypeArray.toString = function () { return 'function MimeTypeArray() { [native code] }'; }
Object.defineProperties(MimeTypeArray.prototype, { [Symbol.toStringTag]: { value: 'MimeTypeArray' } })
MimeTypeArrayc = new MimeTypeArray();
MimeTypeArrayc[Symbol.iterator] = function* () {
    for (let key in this) {
        yield this[key];
    }
}

// 创建电池管理器对象原型 
const BatteryManager = {
    level: 1,
    charging: true,
    chargingTime: 0,
    dischargingTime: null,
    onchargingchange: null,
    onlevelchange: null,
    toString: function toString() {
      return `BatteryManager {
        charging: ${this.charging}, 
        level: ${this.level}, 
        chargingTime: ${this.chargingTime}, 
        dischargingTime: ${this.dischargingTime} 
      }`
    }
}
window.BatteryManager = BatteryManager;

Promise2 = {
    then: function () {
        return this;
    },
    catch: function (){},
};

createTagProto('Bluetooth');
createTagProto('Navigator');
Navigator.prototype.hardwareConcurrency = 8;
Navigator.prototype.userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36';
Navigator.prototype.appVersion = '5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36'
Navigator.prototype.appName = 'Netscape';
Navigator.prototype.appCodeName = 'Mozilla';
Navigator.prototype.vendor = 'Google Inc.';
Navigator.prototype.maxTouchPoints = 10;
Navigator.prototype.platform = 'Win32';
Navigator.prototype.adAuctionComponents = function adAuctionComponents() {
    AsObj.print('adAuctionComponents:::', arguments)
}
safeFunction(Navigator.prototype.adAuctionComponents)
Navigator.prototype.runAdAuction = function runAdAuction() {
    AsObj.print('runAdAuction:::', arguments)
}
safeFunction(Navigator.prototype.runAdAuction)
Navigator.prototype.canLoadAdAuctionFencedFrame = makeFunction('canLoadAdAuctionFencedFrame')
Navigator.prototype.deprecatedReplaceInURN = makeFunction('deprecatedReplaceInURN')
Navigator.prototype.deprecatedURNToURL = makeFunction('deprecatedURNToURL')
Navigator.prototype.joinAdInterestGroup = makeFunction('joinAdInterestGroup')
Navigator.prototype.leaveAdInterestGroup = makeFunction('leaveAdInterestGroup')
Navigator.prototype.updateAdInterestGroups = makeFunction('updateAdInterestGroups')
Navigator.prototype.connection = watch({
    downlink: 9.1,
    effectiveType: '4g',
    rtt: 0,
    saveData: false,
},'connection')
Navigator.prototype.language = 'zh-CN';
Navigator.prototype.languages = ["zh-CN"];
Navigator.prototype.plugins = plugins;
Navigator.prototype.webdriver = false;
Navigator.prototype.cookieEnabled = true;
Navigator.prototype.onLine = true;
Navigator.prototype.doNotTrack = null;
Navigator.prototype.bluetooth = {};
Navigator.prototype.product = 'Gecko'
Navigator.prototype.deviceMemory = 8
Navigator.prototype.mediaDevices = watch({
    enumerateDevices: function enumerateDevices() {
        return new Promise((resolve, reject) => {
            const offer = [
                {deviceId: '', kind: 'audioinput', label: '', groupId: ''},
                {deviceId: '', kind: 'videoinput', label: '', groupId: ''},
                {deviceId: '', kind: 'audiooutput', label: '', groupId: ''},
            ]
            resolve(offer);
        });
    },
    getUserMedia: function getUserMedia() {
        AsObj.print('getUserMedia:::', arguments)
    }
},'mediaDevices')
Navigator.prototype.storage = {
    estimate: function estimate() {
        AsObj.print('estimate:::', arguments)
        return new Promise((resolve, reject) => {
            const offer = {
                usage: 0, // 1GB
                quota: 2147483648, // 1GB,
                usageDetails: {caches: 512, indexedDB: 2855}
            };
            resolve(offer);
        });
    }
}
Navigator.prototype.webkitPersistentStorage = watch({},'webkitPersistentStorage')
Navigator.prototype.webkitTemporaryStorage = watch({
    queryUsageAndQuota: function queryUsageAndQuota() {
        AsObj.print('queryUsageAndQuota:::', arguments)
        return new Promise((resolve, reject) => {    
            const offer = {
                usage: 1024 * 1024 * 1024, // 1GB
                quota: 1024 * 1024 * 1024, // 1GB
            };
            resolve(offer);
        });
    }
},'webkitTemporaryStorage')
Navigator.prototype.bluetooth.__proto__ = Bluetooth.prototype;
Navigator.prototype.javaEnabled = function javaEnabled() {
    return false
};
safeFunction(Navigator.prototype.javaEnabled)
Navigator.prototype.getBattery = function getBattery() {
    AsObj.print('getBattery:::', arguments)
    return Promise.resolve({
        __proto__: BatteryManager,
        // 动态参数配置（示例值）
        level: 1,
        charging: true,
        dischargingTime: null // 2小时放电时间 
    })
}
safeFunction(Navigator.prototype.getBattery)
Navigator.prototype.registerProtocolHandler = function registerProtocolHandler() {
    AsObj.print('registerProtocolHandler:::',arguments)
}
safeFunction(Navigator.prototype.registerProtocolHandler)
Navigator.prototype.mimeTypes = watch(MimeTypeArrayc,'mimeTypes');
Navigator.prototype.geolocation = {
    getCurrentPosition: function getCurrentPosition() {
        return Promise2;
    }
}
Navigator.prototype.pdfViewerEnabled = true;
Navigator.prototype.doNotTrack = null;
Navigator.prototype.keyboard = watch({
    getLayoutMap: function getLayoutMap() {
        AsObj.print('Navigator.prototype.keyboard:', arguments)
        return {
            then: function () {
                // arguments[0](watch({
                //     size: 48,
                //     values: function () {
                //         return ['k', 'g', '2', '0', 'v', 'a', '`', 'l', '\\', "'", 'w', '8', 'm', 'h', '.', '7', '1', 'p', 'd', 'f', 'o', 'q', 'c', 'n', '[', 'z', 'y', '3', '6', '5', 'x', '/', '\\', ',', '-', '4', 'b', 't', '9', 's', 'i', 'u', '=', 'j', ';', 'r', ']', 'e']
                //     }
                // }, 'navigator.keyboard.getLayoutMap.then'))
                return {
                    catch: function () {
                        arguments[0]({
                            message:'getLayoutMap() must be called from a top-level browsing context or allowed by the permission policy.'
                        })
                    }
                }
            }
        }
    }
},'navigator.keyboard')
Navigator.prototype.permissions = watch({
    query: function query() {
        arg_obj = arguments[0];
        if (arg_obj.name === 'audio_capture') {
            return new Promise((resolve, reject) => {    
                const offer = {
                    state: 'prompt',
                    onchange: null,
                    name:arg_obj.name
                };
                resolve(offer);
            });
        }
        if (arg_obj.name === 'microphone') {
            return {
                then: function () {
                    arguments[0](watch({
                        state: 'denied',
                        onchange: null,
                        name: 'audio_capture'
                    },'permissions.query.microphone'));
                    return {catch:function(){}}
                },
                catch:function(){}
            }
        }
        if (arg_obj.name === 'camera') {
            return {
                then: function () {
                    arguments[0](watch({
                        state: 'prompt',
                        onchange: null,
                        name: 'video_capture'
                    },'permissions.query.camera'));
                    return {catch:function(){}}
                },
                catch:function(){}
            }
        }
        AsObj.print('permissions.query:::', arguments)
        
    }
},'permissions')
Navigator.prototype.productSub = '20030107'
Navigator.prototype.getGamepads = function getGamepads() {
    AsObj.print('getGamepads:::', arguments)
    return [null,null,null,null]
}
safeFunction(Navigator.prototype.getGamepads)

Navigator.prototype.sendBeacon = makeFunction('sendBeacon')

Navigator.prototype.deprecatedRunAdAuctionEnforcesKAnonymity = false
Navigator.prototype.gpu = watch({
    getPreferredCanvasFormat: function getPreferredCanvasFormat() {
        AsObj.print('gpu.getPreferredCanvasFormat:', arguments)
        return 'bgra8unorm'
    },
    wgslLanguageFeatures: watch({
        size: 7,
        values: function values() {
            debugger
            AsObj.print('wgslLanguageFeatures.values')
            return ['packed_4x8_integer_dot_product', 'unrestricted_pointer_parameters', 'subgroup_uniformity', 'subgroup_id', 'pointer_composite_access', 'readonly_and_readwrite_storage_textures', 'uniform_buffer_standard_layout']
        },
    }, 'gpu.wgslLanguageFeatures'),
    requestAdapter: function requestAdapter() {
        AsObj.print('gpu.requestAdapter:', arguments)
        return {
            then: function () {
                arguments[0](watch({
                    features: watch({
                        size: 19,
                        values: function () {
                            return ['depth32float-stencil8', 'rg11b10ufloat-renderable', 'bgra8unorm-storage', 'texture-formats-tier1', 'texture-compression-bc', 'dual-source-blending', 'core-features-and-limits', 'float32-filterable', 'indirect-first-instance', 'float32-blendable', 'depth-clip-control', 'texture-compression-bc-sliced-3d', 'timestamp-query', 'texture-formats-tier2', 'clip-distances', 'shader-f16', 'primitive-index', 'texture-component-swizzle', 'subgroups']
                        }
                    }, 'gpu.requestAdapter.features'),
                    info: watch({ vendor: 'intel', architecture: 'gen-11', device: '', description: '', subgroupMinSize: 16 }, 'gpu.requestAdapter.info'),
                    limits: watch({
                        maxBufferSize: 2147483648,
                        maxStorageBufferBindingSize:2147483644
                    }, 'gpu.requestAdapter.limits'),
                    catch:function(){}
                }, 'gpu.requestAdapter'));
                return {
                    catch: function () {
                        return {
                            then: function () {
                                arguments[0]()
                                return {catch:function(){}}
                            }
                        }
                    }
                };
            },
            catch: function () {
            }
        }
    }
},'navigator.gpu')
Navigator.prototype.userAgentData = watch({
    brands:[
        {
            "brand": "Google Chrome",
            "version": "143"
        },
        {
            "brand": "Chromium",
            "version": "143"
        },
        {
            "brand": "Not A(Brand",
            "version": "24"
        }
    ],
    mobile: false,
    platform: "Windows",
    getHighEntropyValues: function getHighEntropyValues() {
        if (arguments[0] + '' === 'architecture,bitness,model,platformVersion,uaFullVersion,wow64') {
            return new Promise((resolve, reject) => {    
                const offer = {
                    "architecture": "x86",
                    "bitness": "64",
                    "brands": [
                        {
                            "brand": "Not:A-Brand",
                            "version": "99"
                        },
                        {
                            "brand": "Google Chrome",
                            "version": "145"
                        },
                        {
                            "brand": "Chromium",
                            "version": "145"
                        }
                    ],
                    "mobile": false,
                    "model": "",
                    "platform": "Windows",
                    "platformVersion": "10.0.0",
                    "uaFullVersion": "145.0.7632.117",
                    "wow64": false
                };
                resolve(offer);
            });
        }
        AsObj.print('getHighEntropyValues:::', arguments)
    }
},'userAgentData')

navigator = {};
navigator.__proto__ = Navigator.prototype;

createTagProto('Location');
location = {
    "ancestorOrigins": {},
    "href": "https://www.neimanmarcus.com/",
    "origin": "https://www.neimanmarcus.com",
    "protocol": "https:",
    "host": "www.neimanmarcus.com",
    "hostname": "www.neimanmarcus.com",
    "port": "",
    "pathname": "/",
    "search": "",
    "hash": ""
};

location.__proto__ = Location.prototype;
location.toString = function toString() {
    return this.href;
}

createTagProto('Screen');
Screen.prototype = Object.assign(Screen.prototype, {
    availHeight: 824,
    availLeft: 0,
    availTop: 0,
    availWidth: 1536,
    colorDepth: 32,
    height: 864,
    isExtended: true,
    onchange: null,
    pixelDepth: 24,
    width: 1536,
    orientation:  {
        angle: 0,
        type: "landscape-primary",
        onchange: null
    }
})
screen = {};
screen.__proto__ = Screen.prototype;

createTagProto('History',['replaceState']);
history = {};
history.__proto__ = History.prototype;

chrome = {
    loadTimes: function loadTimes() { },
    csi: function csi() { },
    app: {
        InstallState: { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' },
        RunningState: { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' },
        getDetails:function getDetails(){},
        getIsInstalled:function getIsInstalled(){},
        installState:function installState(){},
        isInstalled: false,
        runningState: function runningState(){}
    },
}

createTagProto('Storage');
local = {
};
localStorage = {
    getItem: function getItem(key) {
        AsObj.print("localStorage.getItem::", arguments);
        if (!local[key]) {
            return null;
        }
        return local[key];
    },
    setItem: function setItem(key, value) {
        AsObj.print("localStorage.setItem::", arguments);
        local[key] = value;
    },
    clear: function clear() {
        local = {};
    },
    removeItem: function removeItem(key) {
        AsObj.print("localStorage.removeItem::", arguments);
        delete local[key];
    }
}
localStorage.__proto__ = Storage.prototype;
sessionStorage = {
    getItem: function getItem(key) {
        AsObj.print("sessionStorage.getItem::", arguments);
        if (!local[key]) {
            return null;
        }
        return local[key];
    },
    setItem: function setItem(key, value) {
        AsObj.print("sessionStorage.setItem::", arguments);
        local[key] = value;
    },
    clear: function clear() {
        local = {};
    },
    removeItem: function removeItem(key) {
        AsObj.print("sessionStorage.removeItem::", arguments);
        delete local[key];
    }
}
sessionStorage.__proto__ = Storage.prototype;

// window = watch(window, 'window');
// global = watch(global, 'global');
// globalThis = watch(globalThis, 'globalThis');
// self = watch(self, 'self');
// crypto = watch(crypto, 'crypto');
// performance = watch(performance, 'performance');
// document = watch(document, 'document');
// navigator = watch(navigator, 'navigator');
// location = watch(location, 'location');
// screen = watch(screen, 'screen');
// history = watch(history, 'history');
// localStorage = watch(localStorage, 'localStorage');
// sessionStorage = watch(sessionStorage, 'sessionStorage');
// chrome = watch(chrome, 'chrome');

require_('./sdk_leg.js');

let input = '';
// 收集数据
process.stdin.on('data', chunk => {
    input += chunk;
});
process.stdin.on('end', async () => {
    var config_data = JSON.parse(input);
    var cryptoManager = await CaptchaSDKCorecc();
    var encryptData = await buildEncryptedVerifyRequestcc(config_data, cryptoManager);
    console.log(JSON.stringify(encryptData));
    process.exit(0);
})