javascript-obfuscator 2.18.1 → 3.0.1

package/src/custom-code-helpers/debug-protection/group/DebugProtectionCodeHelperGroup.ts

@@ -1,159 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import { TCustomCodeHelperFactory } from '../../../types/container/custom-code-helpers/TCustomCodeHelperFactory';
-import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
-import { TInitialData } from '../../../types/TInitialData';
-import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
-import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
-
-import { ICustomCodeHelper } from '../../../interfaces/custom-code-helpers/ICustomCodeHelper';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-import { ICallsGraphData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
-
-import { initializable } from '../../../decorators/Initializable';
-
-import { CustomCodeHelper } from '../../../enums/custom-code-helpers/CustomCodeHelper';
-import { NodeTransformationStage } from '../../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractCustomCodeHelperGroup } from '../../AbstractCustomCodeHelperGroup';
-import { CallsControllerFunctionCodeHelper } from '../../calls-controller/CallsControllerFunctionCodeHelper';
-import { DebugProtectionFunctionCodeHelper } from '../DebugProtectionFunctionCodeHelper';
-import { DebugProtectionFunctionCallCodeHelper } from '../DebugProtectionFunctionCallCodeHelper';
-import { DebugProtectionFunctionIntervalCodeHelper } from '../DebugProtectionFunctionIntervalCodeHelper';
-import { NodeAppender } from '../../../node/NodeAppender';
-import { NodeGuards } from '../../../node/NodeGuards';
-import { NodeLexicalScopeUtils } from '../../../node/NodeLexicalScopeUtils';
-
-@injectable()
-export class DebugProtectionCodeHelperGroup extends AbstractCustomCodeHelperGroup {
-    /**
-     * @type {Map<CustomCodeHelper, ICustomCodeHelper>}
-     */
-    @initializable()
-    protected customCodeHelpers!: Map <CustomCodeHelper, ICustomCodeHelper>;
-
-    /**
-     * @type {TCustomCodeHelperFactory}
-     */
-    private readonly customCodeHelperFactory: TCustomCodeHelperFactory;
-
-    /**
-     * @param {TCustomCodeHelperFactory} customCodeHelperFactory
-     * @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__ICustomCodeHelper) customCodeHelperFactory: TCustomCodeHelperFactory,
-        @inject(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
-            identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(identifierNamesGeneratorFactory, randomGenerator, options);
-
-        this.customCodeHelperFactory = customCodeHelperFactory;
-    }
-
-    /**
-     * @param {TNodeWithStatements} nodeWithStatements
-     * @param {ICallsGraphData[]} callsGraphData
-     */
-    public appendOnPreparingStage (nodeWithStatements: TNodeWithStatements, callsGraphData: ICallsGraphData[]): void {
-        if (!this.options.debugProtection) {
-            return;
-        }
-
-        const randomCallsGraphIndex: number = this.getRandomCallsGraphIndex(callsGraphData.length);
-
-        const debugProtectionFunctionCallHostNode: TNodeWithStatements = callsGraphData.length
-            ? NodeAppender.getOptimalBlockScope(callsGraphData, randomCallsGraphIndex)
-            : nodeWithStatements;
-        const callsControllerHostNode: TNodeWithStatements = callsGraphData.length
-            ? NodeAppender.getOptimalBlockScope(callsGraphData, randomCallsGraphIndex, 1)
-            : nodeWithStatements;
-
-        const debugProtectionFunctionCallScopeNode: TNodeWithLexicalScope | null = NodeLexicalScopeUtils
-            .getLexicalScope(debugProtectionFunctionCallHostNode) ?? null;
-
-        const debugProtectionFunctionName: string = debugProtectionFunctionCallScopeNode
-            ? this.identifierNamesGenerator.generate(debugProtectionFunctionCallScopeNode)
-            : this.identifierNamesGenerator.generateNext();
-        const callsControllerFunctionName: string = debugProtectionFunctionCallScopeNode
-            ? this.identifierNamesGenerator.generate(debugProtectionFunctionCallScopeNode)
-            : this.identifierNamesGenerator.generateNext();
-
-        // debugProtectionFunctionCall helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.DebugProtectionFunctionCall,
-            (customCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionCallCodeHelper>>) => {
-                customCodeHelper.initialize(debugProtectionFunctionName, callsControllerFunctionName);
-
-                NodeAppender.prepend(debugProtectionFunctionCallHostNode, customCodeHelper.getNode());
-            }
-        );
-
-        // nodeCallsControllerFunction helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.CallsControllerFunction,
-            (customCodeHelper: ICustomCodeHelper<TInitialData<CallsControllerFunctionCodeHelper>>) => {
-                customCodeHelper.initialize(NodeTransformationStage.Preparing, callsControllerFunctionName);
-
-                NodeAppender.prepend(callsControllerHostNode, customCodeHelper.getNode());
-            }
-        );
-
-        // debugProtectionFunction helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.DebugProtectionFunction,
-                (customCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionCodeHelper>>) => {
-                customCodeHelper.initialize(debugProtectionFunctionName);
-
-                NodeAppender.append(nodeWithStatements, customCodeHelper.getNode());
-            }
-        );
-
-        // debugProtectionFunctionInterval helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.DebugProtectionFunctionInterval,
-            (customCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionIntervalCodeHelper>>) => {
-                const programBodyLength: number = NodeGuards.isSwitchCaseNode(nodeWithStatements)
-                    ? nodeWithStatements.consequent.length
-                    : nodeWithStatements.body.length;
-                const randomIndex: number = this.randomGenerator.getRandomInteger(0, programBodyLength);
-
-                customCodeHelper.initialize(debugProtectionFunctionName);
-
-                NodeAppender.insertAtIndex(nodeWithStatements, customCodeHelper.getNode(), randomIndex);
-            }
-        );
-    }
-
-    public initialize (): void {
-        this.customCodeHelpers = new Map <CustomCodeHelper, ICustomCodeHelper>();
-
-        if (!this.options.debugProtection) {
-            return;
-        }
-
-        const debugProtectionFunctionCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.DebugProtectionFunction);
-        const debugProtectionFunctionCallCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionCallCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.DebugProtectionFunctionCall);
-        const debugProtectionFunctionIntervalCodeHelper: ICustomCodeHelper<TInitialData<DebugProtectionFunctionIntervalCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.DebugProtectionFunctionInterval);
-        const callsControllerFunctionCodeHelper: ICustomCodeHelper<TInitialData<CallsControllerFunctionCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.CallsControllerFunction);
-
-        this.customCodeHelpers.set(CustomCodeHelper.DebugProtectionFunction, debugProtectionFunctionCodeHelper);
-        this.customCodeHelpers.set(CustomCodeHelper.DebugProtectionFunctionCall, debugProtectionFunctionCallCodeHelper);
-
-        if (this.options.debugProtectionInterval) {
-            this.customCodeHelpers.set(CustomCodeHelper.DebugProtectionFunctionInterval, debugProtectionFunctionIntervalCodeHelper);
-        }
-
-        this.customCodeHelpers.set(CustomCodeHelper.CallsControllerFunction, callsControllerFunctionCodeHelper);
-    }
-}

package/src/custom-code-helpers/debug-protection/templates/debug-protection-function/DebugProtectionFunctionTemplate.ts

@@ -1,23 +0,0 @@
-/**
- * @returns {string}
- */
-export function DebugProtectionFunctionTemplate (): string {
-    return `
-        function {debugProtectionFunctionName} (ret) {
-            function debuggerProtection (counter) {
-            
-                {debuggerTemplate}
-                
-                debuggerProtection(++counter);
-            }
-            
-            try {
-                if (ret) {
-                    return debuggerProtection;
-                } else {
-                    debuggerProtection(0);
-                }
-            } catch (y) {}
-        }
-    `;
-}

package/src/custom-code-helpers/debug-protection/templates/debug-protection-function/DebuggerTemplate.ts

@@ -1,17 +0,0 @@
-/**
- * @returns {string}
- */
-export function DebuggerTemplate (): string {
-    return `
-        if (typeof counter === 'string') {
-            return (function (arg) {}.constructor('while (true) {}').apply('counter'));
-        } else {
-            if (('' + counter / counter)['length'] !== 1 || counter % 20 === 0) {
-                (function () {return true;}.constructor('debu' + 'gger').call('action'));
-            } else {
-                (function () {return false;}.constructor('debu' + 'gger').apply('stateObject'));
-            }
-            
-        }
-    `;
-}

package/src/custom-code-helpers/debug-protection/templates/debug-protection-function/DebuggerTemplateNoEval.ts

@@ -1,21 +0,0 @@
-/**
- * @returns {string}
- */
-export function DebuggerTemplateNoEval (): string {
-    return `
-        if (typeof counter === 'string') {
-            const func = function () {
-                while (true) {}
-            };
-            
-            return func();
-        } else {
-            if (('' + counter / counter)['length'] !== 1 || counter % 20 === 0) {
-                debugger;
-            } else {
-                debugger;
-            }
-            
-        }
-    `;
-}

package/src/custom-code-helpers/debug-protection/templates/debug-protection-function-call/DebugProtectionFunctionCallTemplate.ts

@@ -1,24 +0,0 @@
-/**
- * @returns {string}
- */
-export function DebugProtectionFunctionCallTemplate (): string {
-    return `
-        (function () {
-            {callControllerFunctionName}(
-                this,
-                function () {
-                    const regExp1 = new RegExp('function *\\\\( *\\\\)');
-                    const regExp2 = new RegExp('\\\\+\\\\+ *\\(?:[a-zA-Z_$][0-9a-zA-Z_$]*\\)', 'i');
-           
-                    const result = {debugProtectionFunctionName}('init');
-                    
-                    if (!regExp1.test(result + 'chain') || !regExp2.test(result + 'input')) {
-                        result('0');
-                    } else {
-                        {debugProtectionFunctionName}();
-                    }
-                }
-            )();
-        })();
-    `;
-}

package/src/custom-code-helpers/debug-protection/templates/debug-protection-function-interval/DebugProtectionFunctionIntervalTemplate.ts

@@ -1,10 +0,0 @@
-/**
- * @returns {string}
- */
-export function DebugProtectionFunctionIntervalTemplate (): string {
-    return `
-        setInterval(function () {
-            {debugProtectionFunctionName}();
-        }, 4000);
-    `;
-}

package/src/custom-code-helpers/domain-lock/DomainLockCodeHelper.ts

@@ -1,115 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
-import { TStatement } from '../../types/node/TStatement';
-
-import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
-import { ICustomCodeHelperObfuscator } from '../../interfaces/custom-code-helpers/ICustomCodeHelperObfuscator';
-import { ICryptUtils } from '../../interfaces/utils/ICryptUtils';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { ObfuscationTarget } from '../../enums/ObfuscationTarget';
-
-import { initializable } from '../../decorators/Initializable';
-
-import { DomainLockTemplate } from './templates/DomainLockTemplate';
-import { GlobalVariableNoEvalTemplate } from '../common/templates/GlobalVariableNoEvalTemplate';
-
-import { AbstractCustomCodeHelper } from '../AbstractCustomCodeHelper';
-import { NodeUtils } from '../../node/NodeUtils';
-
-@injectable()
-export class DomainLockCodeHelper extends AbstractCustomCodeHelper {
-    /**
-     * @type {string}
-     */
-    @initializable()
-    private callsControllerFunctionName!: string;
-
-    /**
-     * @type {string}
-     */
-    @initializable()
-    private domainLockFunctionName!: string;
-
-    /**
-     * @type {ICryptUtils}
-     */
-    private readonly cryptUtils: ICryptUtils;
-
-    /**
-     * @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
-     * @param {ICustomCodeHelperFormatter} customCodeHelperFormatter
-     * @param {ICustomCodeHelperObfuscator} customCodeHelperObfuscator
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     * @param {ICryptUtils} cryptUtils
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
-            identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
-        @inject(ServiceIdentifiers.ICustomCodeHelperFormatter) customCodeHelperFormatter: ICustomCodeHelperFormatter,
-        @inject(ServiceIdentifiers.ICustomCodeHelperObfuscator) customCodeHelperObfuscator: ICustomCodeHelperObfuscator,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.ICryptUtils) cryptUtils: ICryptUtils
-    ) {
-        super(
-            identifierNamesGeneratorFactory,
-            customCodeHelperFormatter,
-            customCodeHelperObfuscator,
-            randomGenerator,
-            options
-        );
-
-        this.cryptUtils = cryptUtils;
-    }
-
-    /**
-     * @param {string} callsControllerFunctionName
-     * @param {string} domainLockFunctionName
-     */
-    public initialize (callsControllerFunctionName: string, domainLockFunctionName: string): void {
-        this.callsControllerFunctionName = callsControllerFunctionName;
-        this.domainLockFunctionName = domainLockFunctionName;
-    }
-
-    /**
-     * @param {string} codeHelperTemplate
-     * @returns {TStatement[]}
-     */
-    protected getNodeStructure (codeHelperTemplate: string): TStatement[] {
-        return NodeUtils.convertCodeToStructure(codeHelperTemplate);
-    }
-
-    /**
-     * @returns {string}
-     */
-    protected override getCodeHelperTemplate (): string {
-        const domainsString: string = this.options.domainLock.join(';');
-        const domainsLockRedirectUrl: string = this.options.domainLockRedirectUrl;
-        const [hiddenDomainsString, domainsStringDiff]: string[] = this.cryptUtils.hideString(
-            domainsString,
-            domainsString.length * 3
-        );
-        const [hiddenDomainLockRedirectUrl, domainLockRedirectUrlDiff]: string[] = this.cryptUtils.hideString(
-            domainsLockRedirectUrl,
-            domainsLockRedirectUrl.length * 3
-        );
-        const globalVariableTemplate: string = this.options.target !== ObfuscationTarget.BrowserNoEval
-            ? this.getGlobalVariableTemplate()
-            : GlobalVariableNoEvalTemplate();
-
-        return this.customCodeHelperFormatter.formatTemplate(DomainLockTemplate(), {
-            callControllerFunctionName: this.callsControllerFunctionName,
-            domainLockFunctionName: this.domainLockFunctionName,
-            domainsStringDiff,
-            domains: hiddenDomainsString,
-            domainLockRedirectUrlDiff: domainLockRedirectUrlDiff,
-            hiddenDomainLockRedirectUrl: hiddenDomainLockRedirectUrl,
-            globalVariableTemplate
-        });
-    }
-}

package/src/custom-code-helpers/domain-lock/group/DomainLockCustomCodeHelperGroup.ts

@@ -1,121 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import { TCustomCodeHelperFactory } from '../../../types/container/custom-code-helpers/TCustomCodeHelperFactory';
-import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
-import { TInitialData } from '../../../types/TInitialData';
-import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
-import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
-
-import { ICustomCodeHelper } from '../../../interfaces/custom-code-helpers/ICustomCodeHelper';
-import { IOptions } from '../../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
-import { ICallsGraphData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
-
-import { initializable } from '../../../decorators/Initializable';
-
-import { CustomCodeHelper } from '../../../enums/custom-code-helpers/CustomCodeHelper';
-import { NodeTransformationStage } from '../../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractCustomCodeHelperGroup } from '../../AbstractCustomCodeHelperGroup';
-import { CallsControllerFunctionCodeHelper } from '../../calls-controller/CallsControllerFunctionCodeHelper';
-import { DomainLockCodeHelper } from '../DomainLockCodeHelper';
-import { NodeAppender } from '../../../node/NodeAppender';
-import { NodeLexicalScopeUtils } from '../../../node/NodeLexicalScopeUtils';
-
-@injectable()
-export class DomainLockCustomCodeHelperGroup extends AbstractCustomCodeHelperGroup {
-    /**
-     * @type {Map<CustomCodeHelper, ICustomCodeHelper>}
-     */
-    @initializable()
-    protected customCodeHelpers!: Map <CustomCodeHelper, ICustomCodeHelper>;
-
-    /**
-     * @type {TCustomCodeHelperFactory}
-     */
-    private readonly customCodeHelperFactory: TCustomCodeHelperFactory;
-
-    /**
-     * @param {TCustomCodeHelperFactory} customCodeHelperFactory
-     * @param {TIdentifierNamesGeneratorFactory} identifierNamesGeneratorFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__ICustomCodeHelper) customCodeHelperFactory: TCustomCodeHelperFactory,
-        @inject(ServiceIdentifiers.Factory__IIdentifierNamesGenerator)
-            identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(identifierNamesGeneratorFactory, randomGenerator, options);
-
-        this.customCodeHelperFactory = customCodeHelperFactory;
-    }
-
-    /**
-     * @param {TNodeWithStatements} nodeWithStatements
-     * @param {ICallsGraphData[]} callsGraphData
-     */
-    public appendOnPreparingStage (nodeWithStatements: TNodeWithStatements, callsGraphData: ICallsGraphData[]): void {
-        if (!this.options.domainLock.length) {
-            return;
-        }
-
-        const randomCallsGraphIndex: number = this.getRandomCallsGraphIndex(callsGraphData.length);
-
-        const domainLockFunctionHostNode: TNodeWithStatements = callsGraphData.length
-            ? NodeAppender.getOptimalBlockScope(callsGraphData, randomCallsGraphIndex)
-            : nodeWithStatements;
-        const callsControllerHostNode: TNodeWithStatements = callsGraphData.length
-            ? NodeAppender.getOptimalBlockScope(callsGraphData, randomCallsGraphIndex, 1)
-            : nodeWithStatements;
-
-        const domainLockFunctionLexicalScopeNode: TNodeWithLexicalScope | null = NodeLexicalScopeUtils
-            .getLexicalScope(domainLockFunctionHostNode) ?? null;
-
-        const domainLockFunctionName: string = domainLockFunctionLexicalScopeNode
-            ? this.identifierNamesGenerator.generate(domainLockFunctionLexicalScopeNode)
-            : this.identifierNamesGenerator.generateNext();
-        const callsControllerFunctionName: string = domainLockFunctionLexicalScopeNode
-            ? this.identifierNamesGenerator.generate(domainLockFunctionLexicalScopeNode)
-            : this.identifierNamesGenerator.generateNext();
-
-        // domainLock helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.DomainLock,
-            (customCodeHelper: ICustomCodeHelper<TInitialData<DomainLockCodeHelper>>) => {
-                customCodeHelper.initialize(callsControllerFunctionName, domainLockFunctionName);
-
-                NodeAppender.prepend(domainLockFunctionHostNode, customCodeHelper.getNode());
-            }
-        );
-
-        // nodeCallsControllerFunction helper nodes append
-        this.appendCustomNodeIfExist(
-            CustomCodeHelper.CallsControllerFunction,
-            (customCodeHelper: ICustomCodeHelper<TInitialData<CallsControllerFunctionCodeHelper>>) => {
-                customCodeHelper.initialize(NodeTransformationStage.Preparing, callsControllerFunctionName);
-
-                NodeAppender.prepend(callsControllerHostNode, customCodeHelper.getNode());
-            }
-        );
-    }
-
-    public initialize (): void {
-        this.customCodeHelpers = new Map <CustomCodeHelper, ICustomCodeHelper>();
-
-        if (!this.options.domainLock.length) {
-            return;
-        }
-
-        const domainLockCodeHelper: ICustomCodeHelper<TInitialData<DomainLockCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.DomainLock);
-        const callsControllerFunctionCodeHelper: ICustomCodeHelper<TInitialData<CallsControllerFunctionCodeHelper>> =
-            this.customCodeHelperFactory(CustomCodeHelper.CallsControllerFunction);
-
-        this.customCodeHelpers.set(CustomCodeHelper.DomainLock, domainLockCodeHelper);
-        this.customCodeHelpers.set(CustomCodeHelper.CallsControllerFunction, callsControllerFunctionCodeHelper);
-    }
-}

package/src/custom-code-helpers/domain-lock/templates/DomainLockTemplate.ts

@@ -1,119 +0,0 @@
-/**
- * @returns {string}
- */
-export function DomainLockTemplate (): string {
-    return `
-        const {domainLockFunctionName} = {callControllerFunctionName}(this, function () {
-            
-            {globalVariableTemplate}
-            
-            const regExp = new RegExp("[{domainsStringDiff}]", "g");
-            const domains = "{domains}".replace(regExp, "").split(";");
-            let document;
-            let domain;
-            let location;
-            let hostname;
-
-            const isName = function(name, length, cs) {
-                if (name.length != length) {
-                    return false;
-                }
-
-                for (let i = 0; i < length; i++) {
-                    for (let j = 0; j < cs.length; j += 2) {
-                        if (i == cs[j] && name.charCodeAt(i) != cs[j+1]) {
-                            return false;
-                        }
-                    }
-                }
-
-                return true;
-            };
-
-            const isNameVariant1 = function(cs, name, length) {
-              return isName(name, length, cs);
-            };
-
-            const isNameVariant2 = function(name, cs, length) {
-              return isNameVariant1(cs, name, length);
-            };
-
-            const isNameVariant3 = function(length, name, cs) {
-              return isNameVariant2(name, cs, length);
-            };
-
-            for (let d in that) {
-                if (isName(d, 8, [7, 116, 5, 101, 3, 117, 0, 100])) {
-                    document = d;
-                
-                    break;
-                }
-            }
-
-            for (let d1 in that[document]) {
-                if (isNameVariant3(6, d1, [5, 110, 0, 100])) {
-                    domain = d1;
-
-                    break;
-                }
-            }
-
-            for (let d2 in that[document]) {
-                if (isNameVariant2(d2, [7, 110, 0, 108], 8)) {
-                    location = d2;
-
-                    break;
-                }
-            }
-
-            if (!("~" > domain)) {
-                for (let d3 in that[document][location]) {
-                    if (isNameVariant1([7, 101, 0, 104], d3, 8)) {
-                        hostname = d3;
-                        
-                        break;
-                    }
-                }
-            }
-            
-            if (!document || !that[document]) {
-                return;
-            }
-            
-            const documentDomain = that[document][domain];
-            const documentLocationHostName = !!that[document][location] && that[document][location][hostname];
-            const currentDomain = documentDomain || documentLocationHostName;
-          
-            if (!currentDomain) {
-                return;
-            }
-          
-            let ok = false;
-                        
-            for (let i = 0; i < domains.length; i++) {
-                const domain = domains[i];
-                const domainNormalized = domain[0] === String.fromCharCode(46)
-                    ? domain.slice(1)
-                    : domain;
-                const position = currentDomain.length - domainNormalized.length;
-                const lastIndex = currentDomain.indexOf(domainNormalized, position);
-                const endsWith = lastIndex !== -1 && lastIndex === position;
-                
-                if (endsWith) {
-                    if (currentDomain.length == domain.length || domain.indexOf(".") === 0) {
-                        ok = true;
-                    }
-                }
-            }
-
-            if (!ok) {
-                const regExp2 = new RegExp("[{domainLockRedirectUrlDiff}]", "g");
-                const domainLockRedirectUrl = "{hiddenDomainLockRedirectUrl}".replace(regExp2, "");
-
-                that[document][location] = domainLockRedirectUrl;
-            }
-        });
-
-        {domainLockFunctionName}();
-    `;
-}