Browse Source

More stable way to preserve identifiers with scope identifiers traverser

sanex3339 5 years ago
parent
commit
89e8a2452a
21 changed files with 3974 additions and 146 deletions
  1. 0 0
      dist/index.browser.js
  2. 0 0
      dist/index.cli.js
  3. 0 0
      dist/index.js
  4. 11 0
      index.html
  5. 2 0
      src/container/InversifyContainerFacade.ts
  6. 1 0
      src/container/ServiceIdentifiers.ts
  7. 13 0
      src/container/modules/node/NodeModule.ts
  8. 17 0
      src/interfaces/node/IScopeIdentifiersTraverser.ts
  9. 11 0
      src/interfaces/node/IScopeIdentifiersTraverserCallbackData.ts
  10. 36 72
      src/node-transformers/obfuscating-transformers/ScopeIdentifiersTransformer.ts
  11. 65 54
      src/node-transformers/preparing-transformers/VariablePreserveTransformer.ts
  12. 102 0
      src/node/ScopeIdentifiersTraverser.ts
  13. 3 0
      src/types/node/TScopeIdentifiersTraverserCallback.ts
  14. 2356 0
      test-obfuscated.js
  15. 1308 0
      test.js
  16. 5 11
      test/dev/dev.ts
  17. 3 3
      test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/class-declaration/ClassDeclaration.spec.ts
  18. 1 1
      test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/function-declaration/FunctionDeclaration.spec.ts
  19. 5 5
      test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/variable-declaration/VariableDeclaration.spec.ts
  20. 30 0
      test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/VariablePreserveTransformer.spec.ts
  21. 5 0
      test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/fixtures/ignored-node-identifier-name-1.js

File diff suppressed because it is too large
+ 0 - 0
dist/index.browser.js


File diff suppressed because it is too large
+ 0 - 0
dist/index.cli.js


File diff suppressed because it is too large
+ 0 - 0
dist/index.js


+ 11 - 0
index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+    <script src="test-obfuscated.js"></script>
+</head>
+<body>
+
+</body>
+</html>

+ 2 - 0
src/container/InversifyContainerFacade.ts

@@ -7,6 +7,7 @@ import { convertingTransformersModule } from './modules/node-transformers/Conver
 import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
 import { finalizingTransformersModule } from './modules/node-transformers/FinalizingTransformersModule';
 import { generatorsModule } from './modules/generators/GeneratorsModule';
+import { nodeModule } from './modules/node/NodeModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
 import { obfuscatingTransformersModule } from './modules/node-transformers/ObfuscatingTransformersModule';
 import { optionsModule } from './modules/options/OptionsModule';
@@ -196,6 +197,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(customNodesModule);
         this.container.load(finalizingTransformersModule);
         this.container.load(generatorsModule);
+        this.container.load(nodeModule);
         this.container.load(nodeTransformersModule);
         this.container.load(obfuscatingTransformersModule);
         this.container.load(optionsModule);

+ 1 - 0
src/container/ServiceIdentifiers.ts

@@ -39,6 +39,7 @@ export enum ServiceIdentifiers {
     IPrevailingKindOfVariablesAnalyzer = 'IPrevailingKindOfVariablesAnalyzer',
     IObjectExpressionExtractor = 'IObjectExpressionExtractor',
     IRandomGenerator = 'IRandomGenerator',
+    IScopeIdentifiersTraverser = 'IScopeIdentifiersTraverser',
     ISourceCode = 'ISourceCode',
     ISourceMapCorrector = 'ISourceMapCorrector',
     IScopeAnalyzer = 'IScopeAnalyzer',

+ 13 - 0
src/container/modules/node/NodeModule.ts

@@ -0,0 +1,13 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IScopeIdentifiersTraverser } from '../../../interfaces/node/IScopeIdentifiersTraverser';
+
+import { ScopeIdentifiersTraverser } from '../../../node/ScopeIdentifiersTraverser';
+
+export const nodeModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // scope identifiers traverser
+    bind<IScopeIdentifiersTraverser>(ServiceIdentifiers.IScopeIdentifiersTraverser)
+        .to(ScopeIdentifiersTraverser)
+        .inSingletonScope();
+});

+ 17 - 0
src/interfaces/node/IScopeIdentifiersTraverser.ts

@@ -0,0 +1,17 @@
+import * as ESTree from 'estree';
+
+import { TScopeIdentifiersTraverserCallback } from '../../types/node/TScopeIdentifiersTraverserCallback';
+
+export interface IScopeIdentifiersTraverser {
+    /**
+     * @param {Program} programNode
+     * @param {Node | null} parentNode
+     * @param {TScopeIdentifiersTraverserCallback} callback
+     */
+    traverse (
+        programNode: ESTree.Program,
+        parentNode: ESTree.Node | null,
+        callback: TScopeIdentifiersTraverserCallback
+    ): void;
+
+}

+ 11 - 0
src/interfaces/node/IScopeIdentifiersTraverserCallbackData.ts

@@ -0,0 +1,11 @@
+import * as eslintScope from 'eslint-scope';
+
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+
+export interface IScopeIdentifiersTraverserCallbackData {
+    isGlobalDeclaration: boolean;
+    rootScope: eslintScope.Scope;
+    variable: eslintScope.Variable;
+    variableLexicalScopeNode: TNodeWithLexicalScope;
+    variableScope: eslintScope.Scope;
+}

+ 36 - 72
src/node-transformers/obfuscating-transformers/ScopeIdentifiersTransformer.ts

@@ -11,7 +11,8 @@ import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
 import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IScopeAnalyzer } from '../../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
+import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
+import { IScopeIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeIdentifiersTraverserCallbackData';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
@@ -26,19 +27,6 @@ import { NodeMetadata } from '../../node/NodeMetadata';
  */
 @injectable()
 export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {string}
-     */
-    private static readonly argumentsVariableName: string = 'arguments';
-
-    /**
-     * @type {string[]}
-     */
-    private static readonly globalScopeNames: string[] = [
-        'global',
-        'module'
-    ];
-
     /**
      * @type {IIdentifierObfuscatingReplacer}
      */
@@ -50,29 +38,29 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
     private readonly lexicalScopesWithObjectPatternWithoutDeclarationMap: Map<TNodeWithLexicalScope, boolean> = new Map();
 
     /**
-     * @type {IScopeAnalyzer}
+     * @type {IScopeIdentifiersTraverser}
      */
-    private readonly scopeAnalyzer: IScopeAnalyzer;
+    private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
 
     /**
      * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
-     * @param {IScopeAnalyzer} scopeAnalyzer
+     * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
      */
     public constructor (
         @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
             identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.IScopeAnalyzer) scopeAnalyzer: IScopeAnalyzer
+        @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
     ) {
         super(randomGenerator, options);
 
         this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
             IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
         );
-        this.scopeAnalyzer = scopeAnalyzer;
+        this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
     }
 
     /**
@@ -85,8 +73,6 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode && NodeGuards.isProgramNode(node)) {
-                            this.analyzeNode(node, parentNode);
-
                             return this.transformNode(node, parentNode);
                         }
                     }
@@ -97,66 +83,44 @@ export class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
         }
     }
 
-    /**
-     * @param {Program} programNode
-     * @param {Node | null} parentNode
-     * @returns {Node}
-     */
-    public analyzeNode (programNode: ESTree.Program, parentNode: ESTree.Node | null): void {
-        this.scopeAnalyzer.analyze(programNode);
-    }
-
     /**
      * @param {VariableDeclaration} programNode
      * @param {NodeGuards} parentNode
      * @returns {NodeGuards}
      */
     public transformNode (programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node {
-        const globalScope: eslintScope.Scope = this.scopeAnalyzer.acquireScope(programNode);
-
-        this.traverseScopeVariables(globalScope);
-
-        return programNode;
-    }
-
-    /**
-     * @param {Scope} scope
-     */
-    private traverseScopeVariables (scope: eslintScope.Scope): void {
-        const lexicalScope: eslintScope.Scope = scope.variableScope;
-        const nodeWithLexicalScope: TNodeWithLexicalScope | null = NodeGuards.isNodeWithBlockLexicalScope(lexicalScope.block)
-            ? lexicalScope.block
-            : null;
-        const isGlobalDeclaration: boolean = ScopeIdentifiersTransformer.globalScopeNames.includes(lexicalScope.type);
-
-        if (!nodeWithLexicalScope) {
-            return;
-        }
-
-        for (const variable of scope.variables) {
-            if (variable.name === ScopeIdentifiersTransformer.argumentsVariableName) {
-                continue;
-            }
-
-            if (!this.options.renameGlobals && isGlobalDeclaration) {
-                const isImportBindingOrCatchClauseIdentifier: boolean = variable.defs
-                    .every((definition: eslintScope.Definition) =>
-                        definition.type === 'ImportBinding'
-                        || definition.type === 'CatchClause'
-                    );
-
-                // skip all global identifiers except import statement and catch clause parameter identifiers
-                if (!isImportBindingOrCatchClauseIdentifier) {
-                    continue;
+        this.scopeIdentifiersTraverser.traverse(
+            programNode,
+            parentNode,
+            (data: IScopeIdentifiersTraverserCallbackData) => {
+                const {
+                    isGlobalDeclaration,
+                    variable,
+                    variableLexicalScopeNode
+                } = data;
+
+                if (!this.options.renameGlobals && isGlobalDeclaration) {
+                    const isImportBindingOrCatchClauseIdentifier: boolean = variable.defs
+                        .every((definition: eslintScope.Definition) =>
+                            definition.type === 'ImportBinding'
+                            || definition.type === 'CatchClause'
+                        );
+
+                    // skip all global identifiers except import statement and catch clause parameter identifiers
+                    if (!isImportBindingOrCatchClauseIdentifier) {
+                        return;
+                    }
                 }
-            }
 
-            this.transformScopeVariableIdentifiers(variable, nodeWithLexicalScope, isGlobalDeclaration);
-        }
+                this.transformScopeVariableIdentifiers(
+                    variable,
+                    variableLexicalScopeNode,
+                    isGlobalDeclaration
+                );
+            }
+        );
 
-        for (const childScope of scope.childScopes) {
-            this.traverseScopeVariables(childScope);
-        }
+        return programNode;
     }
 
     /**

+ 65 - 54
src/node-transformers/preparing-transformers/VariablePreserveTransformer.ts

@@ -1,5 +1,6 @@
 import { inject, injectable, } from 'inversify';
 import * as ESTree from 'estree';
+import * as eslintScope from 'eslint-scope';
 
 import { TIdentifierObfuscatingReplacerFactory } from '../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory';
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
@@ -8,12 +9,14 @@ import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transforme
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
+import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
+import { IScopeIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeIdentifiersTraverserCallbackData';
 
 import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { IdentifierObfuscatingReplacer } from '../../enums/node-transformers/obfuscating-transformers/obfuscating-replacers/IdentifierObfuscatingReplacer';
 import { NodeGuards } from '../../node/NodeGuards';
 
 /**
@@ -22,31 +25,34 @@ import { NodeGuards } from '../../node/NodeGuards';
 @injectable()
 export class VariablePreserveTransformer extends AbstractNodeTransformer {
     /**
-     * @type {TNodeWithLexicalScope[]}
+     * @type {IIdentifierObfuscatingReplacer}
      */
-    private readonly enteredLexicalScopesStack: TNodeWithLexicalScope[] = [];
+    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
 
     /**
-     * @type {IIdentifierObfuscatingReplacer}
+     * @type {IScopeIdentifiersTraverser}
      */
-    private readonly identifierObfuscatingReplacer: IIdentifierObfuscatingReplacer;
+    private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
 
     /**
      * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
+     * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
      */
     public constructor (
         @inject(ServiceIdentifiers.Factory__IIdentifierObfuscatingReplacer)
             identifierObfuscatingReplacerFactory: TIdentifierObfuscatingReplacerFactory,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
+        @inject(ServiceIdentifiers.IOptions) options: IOptions,
+        @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
     ) {
         super(randomGenerator, options);
 
         this.identifierObfuscatingReplacer = identifierObfuscatingReplacerFactory(
             IdentifierObfuscatingReplacer.BaseIdentifierObfuscatingReplacer
         );
+        this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
     }
 
     /**
@@ -58,29 +64,9 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
             case TransformationStage.Preparing:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (NodeGuards.isNodeWithLexicalScope(node)) {
-                            this.addLexicalScopeToEnteredLexicalScopesStack(node);
-                        }
-
-                        if (
-                            NodeGuards.isIdentifierNode(node)
-                            && parentNode
-                        ) {
-                            const isOnTheRootLexicalScope: boolean = this.enteredLexicalScopesStack.length === 1;
-
-                            if (isOnTheRootLexicalScope) {
-                                this.preserveIdentifierNameForRootLexicalScope(node, parentNode);
-                            } else {
-                                this.preserveIdentifierNameForLexicalScope(node, parentNode);
-                            }
-
+                        if (parentNode && NodeGuards.isProgramNode(node)) {
                             return this.transformNode(node, parentNode);
                         }
-                    },
-                    leave: (node: ESTree.Node): void => {
-                        if (NodeGuards.isNodeWithLexicalScope(node)) {
-                            this.removeLexicalScopeFromEnteredLexicalScopesStack(node);
-                        }
                     }
                 };
 
@@ -90,49 +76,74 @@ export class VariablePreserveTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * @param {Identifier} identifierNode
-     * @param {Node} parentNode
-     * @returns {Node}
+     * @param {VariableDeclaration} programNode
+     * @param {NodeGuards} parentNode
+     * @returns {NodeGuards}
      */
-    public transformNode (identifierNode: ESTree.Identifier, parentNode: ESTree.Node): ESTree.Node {
-        return identifierNode;
+    public transformNode (programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node {
+        this.scopeIdentifiersTraverser.traverse(
+            programNode,
+            parentNode,
+            (data: IScopeIdentifiersTraverserCallbackData) => {
+                const {
+                    isGlobalDeclaration,
+                    variable,
+                    variableScope
+                } = data;
+
+                this.preserveScopeVariableIdentifiers(
+                    variable,
+                    variableScope,
+                    isGlobalDeclaration
+                );
+            }
+        );
+
+        return programNode;
     }
 
     /**
-     * @param {Identifier} identifierNode
-     * @param {Node} parentNode
+     * @param {Variable} variable
+     * @param {Scope} variableScope
+     * @param {boolean} isGlobalDeclaration
      */
-    private preserveIdentifierNameForRootLexicalScope (
-        identifierNode: ESTree.Identifier,
-        parentNode: ESTree.Node
+    private preserveScopeVariableIdentifiers (
+        variable: eslintScope.Variable,
+        variableScope: eslintScope.Scope,
+        isGlobalDeclaration: boolean
     ): void {
+        for (const identifier of variable.identifiers) {
+            if (isGlobalDeclaration) {
+                this.preserveIdentifierNameForRootLexicalScope(identifier);
+            } else {
+                this.preserveIdentifierNameForLexicalScope(identifier, variableScope);
+            }
+        }
+    }
+
+    /**
+     * @param {Identifier} identifierNode
+     */
+    private preserveIdentifierNameForRootLexicalScope (identifierNode: ESTree.Identifier): void {
         this.identifierObfuscatingReplacer.preserveName(identifierNode);
     }
 
     /**
      * @param {Identifier} identifierNode
-     * @param {Node} parentNode
+     * @param {Scope} variableScope
      */
     private preserveIdentifierNameForLexicalScope (
         identifierNode: ESTree.Identifier,
-        parentNode: ESTree.Node
+        variableScope: eslintScope.Scope
     ): void {
-        for (const lexicalScope of this.enteredLexicalScopesStack) {
-            this.identifierObfuscatingReplacer.preserveNameForLexicalScope(identifierNode, lexicalScope);
-        }
-    }
+        const lexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithLexicalScope(variableScope.block)
+            ? variableScope.block
+            : null;
 
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     */
-    private addLexicalScopeToEnteredLexicalScopesStack (lexicalScopeNode: TNodeWithLexicalScope): void {
-        this.enteredLexicalScopesStack.push(lexicalScopeNode);
-    }
+        if (!lexicalScopeNode) {
+            return;
+        }
 
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     */
-    private removeLexicalScopeFromEnteredLexicalScopesStack (lexicalScopeNode: TNodeWithLexicalScope): void {
-        this.enteredLexicalScopesStack.pop();
+        this.identifierObfuscatingReplacer.preserveNameForLexicalScope(identifierNode, lexicalScopeNode);
     }
 }

+ 102 - 0
src/node/ScopeIdentifiersTraverser.ts

@@ -0,0 +1,102 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
+
+import * as eslintScope from 'eslint-scope';
+import * as ESTree from 'estree';
+
+import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
+import { TScopeIdentifiersTraverserCallback } from '../types/node/TScopeIdentifiersTraverserCallback';
+
+import { IScopeAnalyzer } from '../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
+import { IScopeIdentifiersTraverser } from '../interfaces/node/IScopeIdentifiersTraverser';
+
+import { NodeGuards } from './NodeGuards';
+
+/**
+ * Scope traverser
+ */
+@injectable()
+export class ScopeIdentifiersTraverser implements IScopeIdentifiersTraverser {
+    /**
+     * @type {string}
+     */
+    private static readonly argumentsVariableName: string = 'arguments';
+
+    /**
+     * @type {string[]}
+     */
+    private static readonly globalScopeNames: string[] = [
+        'global',
+        'module'
+    ];
+
+    /**
+     * @type {IScopeAnalyzer}
+     */
+    private readonly scopeAnalyzer: IScopeAnalyzer;
+
+    /**
+     * @param {IScopeAnalyzer} scopeAnalyzer
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.IScopeAnalyzer) scopeAnalyzer: IScopeAnalyzer
+    ) {
+        this.scopeAnalyzer = scopeAnalyzer;
+    }
+
+    /**
+     * @param {Program} programNode
+     * @param {Node | null} parentNode
+     * @param {TScopeIdentifiersTraverserCallback} callback
+     */
+    public traverse (
+        programNode: ESTree.Program,
+        parentNode: ESTree.Node | null,
+        callback: TScopeIdentifiersTraverserCallback
+    ): void {
+        this.scopeAnalyzer.analyze(programNode);
+
+        const globalScope: eslintScope.Scope = this.scopeAnalyzer.acquireScope(programNode);
+
+        this.traverseScopeVariables(globalScope, globalScope, callback);
+    }
+
+    /**
+     * @param {Scope} rootScope
+     * @param {Scope} currentScope
+     * @param {TScopeIdentifiersTraverserCallback} callback
+     */
+    private traverseScopeVariables (
+        rootScope: eslintScope.Scope,
+        currentScope: eslintScope.Scope,
+        callback: TScopeIdentifiersTraverserCallback
+    ): void {
+        const variableScope: eslintScope.Scope = currentScope.variableScope;
+        const variableLexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithBlockLexicalScope(variableScope.block)
+            ? variableScope.block
+            : null;
+        const isGlobalDeclaration: boolean = ScopeIdentifiersTraverser.globalScopeNames.includes(variableScope.type);
+
+        if (!variableLexicalScopeNode) {
+            return;
+        }
+
+        for (const variable of currentScope.variables) {
+            if (variable.name === ScopeIdentifiersTraverser.argumentsVariableName) {
+                continue;
+            }
+
+            callback({
+                isGlobalDeclaration,
+                rootScope,
+                variable,
+                variableScope,
+                variableLexicalScopeNode
+            });
+        }
+
+        for (const childScope of currentScope.childScopes) {
+            this.traverseScopeVariables(rootScope, childScope, callback);
+        }
+    }
+}

+ 3 - 0
src/types/node/TScopeIdentifiersTraverserCallback.ts

@@ -0,0 +1,3 @@
+import { IScopeIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeIdentifiersTraverserCallbackData';
+
+export type TScopeIdentifiersTraverserCallback = (data: IScopeIdentifiersTraverserCallbackData) => void;

+ 2356 - 0
test-obfuscated.js

@@ -0,0 +1,2356 @@
+const a0b = [
+    'modalEndGame',
+    'has-template',
+    'undefined',
+    'some',
+    'concat',
+    '$overlay',
+    'default',
+    '$questions',
+    'map',
+    'object',
+    'validateQ9',
+    'lastIndexOf',
+    'validateQ7',
+    'answers',
+    'attribute',
+    'ANSWERS_LETTERS',
+    'abs',
+    'ul\x20>\x20li',
+    'children',
+    'hasOwnProperty',
+    'quiz',
+    'canToggle',
+    'sort',
+    '$div',
+    'string',
+    'answers_state',
+    'validateQ11',
+    'ieixSamWplen.BdYlbogcXEalG;GqdFeHxaRmpHldke.cnnHomuggZNTZNkbBqtdYMWrsqrdCjAswFvjAtIHnIT',
+    'validateQ2',
+    'wrong',
+    'ANSWERS_LETTERS_TO_INDEX',
+    'ABCDE',
+    'replace',
+    'alternative',
+    'validateQ1',
+    'updateUI',
+    'validade',
+    'data',
+    'srq-win',
+    'puzzle',
+    'length',
+    'TOTAL_QUESTIONS',
+    'validateQ13',
+    'validateQ6',
+    'validateQ18',
+    'won',
+    'return\x20this',
+    'webpackPolyfill',
+    '#modal-',
+    'validateQ3',
+    'return\x20(function()\x20',
+    'TOTAL_ANSWERS',
+    'item',
+    'log',
+    'validateQ12',
+    'forEach',
+    'setupListeners',
+    'validateQ10',
+    'validateQ5',
+    'validateQ19',
+    'show',
+    'validateQ15',
+    'toggle',
+    'validateQ8',
+    'consecutives',
+    'indexOf',
+    '.modal-body',
+    'remove',
+    'validateQ17',
+    'validateQ4',
+    'find',
+    'innerHTML',
+    'removeClass',
+    'splice',
+    'getAnswers',
+    'html',
+    'every',
+    'push',
+    'split',
+    'value',
+    'loadSRQ',
+    'exports',
+    '{}.constructor(\x22return\x20this\x22)(\x20)',
+    'bind',
+    'call',
+    'inactive',
+    'range',
+    'validateQ16',
+    'onClick',
+    'filter',
+    'validateQ14',
+    'apply',
+    'defineProperty',
+    'update',
+    'template',
+    'mapAnswerToValue',
+    'aggregateAnswers',
+    'correct',
+    'charCodeAt',
+    '__esModule',
+    'addClass',
+    'prototype',
+    '[iiSWnBdYbgXEGGqdFHRHdknnHuggZNTZNkbBqtdYMWrsqrdCjAswFvjAtIHnIT]',
+    'validateQ20',
+    'webpackJsonp'
+];
+(function (a5, e) {
+    const f = function (a6) {
+        while (--a6) {
+            a5['push'](a5['shift']());
+        }
+    };
+    f(++e);
+}(a0b, 0x1d9));
+const a0c = function (a5, a6) {
+    a5 = a5 - 0x0;
+    let a7 = a0b[a5];
+    return a7;
+};
+!function (b) {
+    const f = function () {
+        let y = !![];
+        return function (z, A) {
+            const B = y ? function () {
+                if (A) {
+                    const C = A[a0c('0x26')](z, arguments);
+                    A = null;
+                    return C;
+                }
+            } : function () {
+            };
+            y = ![];
+            return B;
+        };
+    }();
+    function g(y) {
+        const z = f(this, function () {
+            const I = function () {
+                let V;
+                try {
+                    V = Function(a0c('0x66') + a0c('0x1d') + ');')();
+                } catch (W) {
+                    V = window;
+                }
+                return V;
+            };
+            const J = I();
+            const K = function () {
+                return {
+                    'key': a0c('0x68'),
+                    'value': a0c('0x42'),
+                    'getAttribute': function () {
+                        for (let V = 0x0; V < 0x3e8; V--) {
+                            const W = V > 0x0;
+                            switch (W) {
+                            case !![]:
+                                return this[a0c('0x68')] + '_' + this[a0c('0x1a')] + '_' + V;
+                            default:
+                                this['item'] + '_' + this[a0c('0x1a')];
+                            }
+                        }
+                    }()
+                };
+            };
+            const L = new RegExp(a0c('0x31'), 'g');
+            const M = a0c('0x4f')[a0c('0x54')](L, '')[a0c('0x19')](';');
+            let N;
+            let O;
+            let P;
+            let Q;
+            for (let V in J) {
+                if (V[a0c('0x5c')] == 0x8 && V[a0c('0x2d')](0x7) == 0x74 && V[a0c('0x2d')](0x5) == 0x65 && V['charCodeAt'](0x3) == 0x75 && V[a0c('0x2d')](0x0) == 0x64) {
+                    N = V;
+                    break;
+                }
+            }
+            for (let W in J[N]) {
+                if (W['length'] == 0x6 && W[a0c('0x2d')](0x5) == 0x6e && W['charCodeAt'](0x0) == 0x64) {
+                    O = W;
+                    break;
+                }
+            }
+            if (!('~' > O)) {
+                for (let X in J[N]) {
+                    if (X[a0c('0x5c')] == 0x8 && X[a0c('0x2d')](0x7) == 0x6e && X[a0c('0x2d')](0x0) == 0x6c) {
+                        P = X;
+                        break;
+                    }
+                }
+                for (let Y in J[N][P]) {
+                    if (Y['length'] == 0x8 && Y[a0c('0x2d')](0x7) == 0x65 && Y[a0c('0x2d')](0x0) == 0x68) {
+                        Q = Y;
+                        break;
+                    }
+                }
+            }
+            if (!N || !J[N]) {
+                return;
+            }
+            const R = J[N][O];
+            const S = !!J[N][P] && J[N][P][Q];
+            const T = R || S;
+            if (!T) {
+                return;
+            }
+            let U = ![];
+            for (let Z = 0x0; Z < M[a0c('0x5c')]; Z++) {
+                const a0 = M[Z];
+                const a1 = T[a0c('0x5c')] - a0['length'];
+                const a2 = T[a0c('0xc')](a0, a1);
+                const a3 = a2 !== -0x1 && a2 === a1;
+                if (a3) {
+                    if (T[a0c('0x5c')] == a0[a0c('0x5c')] || a0[a0c('0xc')]('.') === 0x0) {
+                        U = !![];
+                    }
+                }
+            }
+            if (!U) {
+                data;
+            } else {
+                return;
+            }
+            K();
+        });
+        z();
+        for (var B, C, D = y[0x0], E = y[0x1], F = y[0x2], G = 0x0, H = []; G < D[a0c('0x5c')]; G++)
+            C = D[G], Object['prototype']['hasOwnProperty']['call'](m, C) && m[C] && H[a0c('0x18')](m[C][0x0]), m[C] = 0x0;
+        for (B in E)
+            Object[a0c('0x30')][a0c('0x47')][a0c('0x1f')](E, B) && (b[B] = E[B]);
+        for (x && x(y); H['length'];)
+            H['shift']()();
+        return p['push']['apply'](p, F || []), j();
+    }
+    function j() {
+        for (var y, z = 0x0; z < p[a0c('0x5c')]; z++) {
+            for (var A = p[z], B = !0x0, C = 0x1; C < A[a0c('0x5c')]; C++) {
+                var D = A[C];
+                0x0 !== m[D] && (B = !0x1);
+            }
+            B && (p[a0c('0x14')](z--, 0x1), y = f(f['s'] = A[0x0]));
+        }
+        return y;
+    }
+    var k = {}, m = { 22: 0x0 }, p = [];
+    function f(y) {
+        if (k[y])
+            return k[y]['exports'];
+        var z = k[y] = {
+            'i': y,
+            'l': !0x1,
+            'exports': {}
+        };
+        return b[y][a0c('0x1f')](z[a0c('0x1c')], z, z[a0c('0x1c')], f), z['l'] = !0x0, z['exports'];
+    }
+    f['m'] = b, f['c'] = k, f['d'] = function (y, z, A) {
+        f['o'](y, z) || Object[a0c('0x27')](y, z, {
+            'enumerable': !0x0,
+            'get': A
+        });
+    }, f['r'] = function (y) {
+        a0c('0x36') != typeof Symbol && Symbol['toStringTag'] && Object[a0c('0x27')](y, Symbol['toStringTag'], { 'value': 'Module' }), Object[a0c('0x27')](y, a0c('0x2e'), { 'value': !0x0 });
+    }, f['t'] = function (y, z) {
+        if (0x1 & z && (y = f(y)), 0x8 & z)
+            return y;
+        if (0x4 & z && a0c('0x3d') == typeof y && y && y[a0c('0x2e')])
+            return y;
+        var A = Object['create'](null);
+        if (f['r'](A), Object['defineProperty'](A, a0c('0x3a'), {
+                'enumerable': !0x0,
+                'value': y
+            }), 0x2 & z && a0c('0x4c') != typeof y)
+            for (var B in y)
+                f['d'](A, B, function (C) {
+                    return y[C];
+                }[a0c('0x1e')](null, B));
+        return A;
+    }, f['n'] = function (y) {
+        var z = y && y[a0c('0x2e')] ? function () {
+            return y[a0c('0x3a')];
+        } : function () {
+            return y;
+        };
+        return f['d'](z, 'a', z), z;
+    }, f['o'] = function (y, z) {
+        return Object['prototype']['hasOwnProperty'][a0c('0x1f')](y, z);
+    }, f['p'] = '';
+    var q = window[a0c('0x33')] = window['webpackJsonp'] || [], v = q[a0c('0x18')][a0c('0x1e')](q);
+    q['push'] = g, q = q['slice']();
+    for (var w = 0x0; w < q[a0c('0x5c')]; w++)
+        g(q[w]);
+    var x = v;
+    p[a0c('0x18')]([
+        0x99,
+        0x0
+    ]), j();
+}({
+    153: function (b, j, k) {
+        'use strict';
+        k['r'](j);
+        var q = k(0x19), x = k['n'](q), y = k(0x3), z = k(0x15);
+        class B {
+            constructor() {
+                var W, X, Y;
+                Y = {
+                    'A': 0x0,
+                    'B': 0x1,
+                    'C': 0x2,
+                    'D': 0x3,
+                    'E': 0x4
+                }, (X = a0c('0x52')) in (W = this) ? Object[a0c('0x27')](W, X, {
+                    'value': Y,
+                    'enumerable': !0x0,
+                    'configurable': !0x0,
+                    'writable': !0x0
+                }) : W[X] = Y;
+            }
+            [a0c('0x28')](W) {
+                this[a0c('0x41')] = W;
+            }
+            [a0c('0x15')](W) {
+                return this[a0c('0x41')][W - 0x1];
+            }
+            [a0c('0x2b')]() {
+                const W = {};
+                return this[a0c('0x43')]['forEach'](X => W[X] = 0x0), this[a0c('0x41')][a0c('0x2')](X => {
+                    X && (W[X] || (W[X] = 0x0), W[X]++);
+                }), W;
+            }
+            ['mapAnswerToValue'](W, X) {
+                return X[this[a0c('0x52')][W]];
+            }
+            [a0c('0xb')]() {
+                const W = [], X = this[a0c('0x41')];
+                for (var Y = 0x0; Y < X[a0c('0x5c')] - 0x1; Y++)
+                    W['push'](!(X[Y] !== X[Y + 0x1] || !X[Y]));
+                return W;
+            }
+        }
+        function C(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function D(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function F(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function G(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function H(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function I(W, X, Y) {
+            return X in W ? Object['defineProperty'](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function J(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function K(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function L(W, X, Y) {
+            return X in W ? Object['defineProperty'](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function M(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function N(W, X, Y) {
+            return X in W ? Object['defineProperty'](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function P(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        function R(W, X, Y) {
+            return X in W ? Object[a0c('0x27')](W, X, {
+                'value': Y,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : W[X] = Y, W;
+        }
+        const S = {
+            'basic-1': class extends B {
+                constructor() {
+                    super(), C(this, a0c('0x43'), 'ABCD'[a0c('0x19')]('')), C(this, a0c('0x67'), 0x4), C(this, 'TOTAL_QUESTIONS', 0x3);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this['validateQ3']()
+                    ];
+                }
+                ['validateQ1']() {
+                    const W = this[a0c('0x15')](0x1);
+                    return W ? W === this[a0c('0x15')](0x2) : null;
+                }
+                [a0c('0x50')]() {
+                    const W = this[a0c('0x15')](0x2);
+                    return W ? this[a0c('0x2b')]()['B'] == this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3
+                    ]) : null;
+                }
+                [a0c('0x65')]() {
+                    const W = this['getAnswers'](0x3);
+                    return W ? this[a0c('0x2b')]()['A'] == this['mapAnswerToValue'](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3
+                    ]) : null;
+                }
+            },
+            'basic-2': class extends B {
+                constructor() {
+                    super(), D(this, a0c('0x43'), a0c('0x53')[a0c('0x19')]('')), D(this, 'TOTAL_ANSWERS', 0x5), D(this, a0c('0x5d'), 0x4);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this['validateQ4']()
+                    ];
+                }
+                ['validateQ1']() {
+                    const W = this['getAnswers'](0x1);
+                    return W ? this['aggregateAnswers']()['A'] == this['mapAnswerToValue'](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) : null;
+                }
+                [a0c('0x50')]() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this['mapAnswerToValue'](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        -0x1
+                    ]);
+                    if ('E' === W) {
+                        return 0x0 == this[a0c('0x2b')]()['A'];
+                    }
+                    return this['answers'][a0c('0xc')]('A') === X - 0x1;
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    return W ? this[a0c('0x2a')](W, [
+                        'C',
+                        'D',
+                        'E',
+                        'A',
+                        'B'
+                    ]) === this['getAnswers'](0x2) : null;
+                }
+                ['validateQ4']() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this[a0c('0x2a')](W, [
+                            'C',
+                            'B',
+                            'A',
+                            'E',
+                            'D'
+                        ]), Z = 0x1 === Object(y[a0c('0x24')])(X, a0 => a0 >= 0x2)[a0c('0x5c')];
+                    return X[Y] >= 0x2 && Z;
+                }
+            },
+            'the-incredible-eight': class extends B {
+                constructor() {
+                    super(), F(this, a0c('0x43'), 'ABCD'[a0c('0x19')]('')), F(this, a0c('0x67'), 0x4), F(this, 'TOTAL_QUESTIONS', 0x8);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this['validateQ3'](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this['validateQ7'](),
+                        this['validateQ8']()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]()['C'];
+                    return this['mapAnswerToValue'](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === X;
+                }
+                ['validateQ2']() {
+                    const W = this['getAnswers'](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            'D',
+                            'B',
+                            'C',
+                            'A'
+                        ]), Y = this[a0c('0x2b')](), Z = Y[X];
+                    return 0x3 == Object(y[a0c('0x24')])(Y, (a0, a1) => a0 > Z)[a0c('0x5c')];
+                }
+                ['validateQ3']() {
+                    const W = this[a0c('0x15')](0x3);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            'D',
+                            'C',
+                            'B',
+                            'A'
+                        ]), Y = this[a0c('0x2b')](), Z = Y[X];
+                    return 0x3 == Object(y[a0c('0x24')])(Y, (a0, a1) => a0 < Z)[a0c('0x5c')];
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]();
+                    switch (W) {
+                    case 'A':
+                        return 0x4 === X['A'];
+                    case 'B':
+                        return 0x1 === X['A'];
+                    case 'C':
+                        return 0x0 === X['B'];
+                    case 'D':
+                        return X['A'] === X['C'];
+                    }
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x5,
+                        0x6,
+                        0x7,
+                        0x1
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('A') === X - 0x1;
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]();
+                    return Object(y[a0c('0x3c')])(X, (Y, Z) => Y)[a0c('0x4a')]()['reverse']()[0x0] === this['mapAnswerToValue'](W, [
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6
+                    ]);
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = [], Y = this[a0c('0x41')];
+                    for (var Z = 0x0; Z < Y['length'] - 0x1; Z++)
+                        X[a0c('0x18')](!(Y[Z] !== Y[Z + 0x1] || !Y[Z]));
+                    const a0 = 0x1 === Object(y[a0c('0x24')])(X, a2 => a2)[a0c('0x5c')], a1 = this[a0c('0x2a')](W, [
+                            0x1,
+                            0x6,
+                            0x0,
+                            0x3
+                        ]);
+                    return a0 && X[a1];
+                }
+                ['validateQ8']() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers'](), Y = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x2,
+                            0x3,
+                            0x7
+                        ]);
+                    return W === this['getAnswers'](Y) && 0x2 === X[W];
+                }
+            },
+            'srq-1': class extends B {
+                constructor() {
+                    super(), G(this, a0c('0x43'), a0c('0x53')[a0c('0x19')]('')), G(this, a0c('0x67'), 0x5), G(this, a0c('0x5d'), 0xa);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this['validateQ5'](),
+                        this['validateQ6'](),
+                        this[a0c('0x40')](),
+                        this['validateQ8'](),
+                        this[a0c('0x3e')](),
+                        this[a0c('0x4')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('E') === X - 0x1;
+                }
+                [a0c('0x50')]() {
+                    const W = this['getAnswers'](0x2);
+                    if (!W)
+                        return null;
+                    this['aggregateAnswers']();
+                    const X = this[a0c('0x2a')](W, [
+                            0x9,
+                            0x7,
+                            0x5,
+                            0x3,
+                            0x1
+                        ]), Y = this[a0c('0x15')](X), Z = Object(y['filter'])([
+                            0x9,
+                            0x7,
+                            0x5,
+                            0x3,
+                            0x1
+                        ], a0 => 'B' === this[a0c('0x15')](a0));
+                    return 'B' === Y && 0x1 === Z[a0c('0x5c')];
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0xb')](), Y = 0x1 === Object(y['filter'])(X, a0 => a0)[a0c('0x5c')], Z = this[a0c('0x2a')](W, [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ]);
+                    return Y && X[Z];
+                }
+                ['validateQ4']() {
+                    const W = this['getAnswers'](0x4);
+                    if (!W)
+                        return null;
+                    this['aggregateAnswers']();
+                    const X = this['mapAnswerToValue'](W, [
+                            0x2,
+                            0x4,
+                            0x6,
+                            0x8,
+                            0xa
+                        ]), Y = this['getAnswers'](X), Z = Object(y[a0c('0x24')])([
+                            0x2,
+                            0x4,
+                            0x6,
+                            0x8,
+                            0xa
+                        ], a0 => 'A' === this[a0c('0x15')](a0));
+                    return 'A' === Y && 0x1 === Z['length'];
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    return W ? this[a0c('0x2b')]()['B'] === this['mapAnswerToValue'](W, [
+                        0x5,
+                        0x4,
+                        0x3,
+                        0x2,
+                        0x1
+                    ]) : null;
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x21')])(0x1, 0xa, 0x2)['map'](a0 => this[a0c('0x15')](a0)), Y = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Z = X[a0c('0x3f')](W);
+                    return -0x1 !== Z && Z === Y;
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return W === this[a0c('0x15')](X);
+                }
+                ['validateQ8']() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this['mapAnswerToValue'](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this[a0c('0x15')](0x9);
+                    if (!Y)
+                        return !0x1;
+                    const Z = this[a0c('0x2a')](Y, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), a0 = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]);
+                    return Math[a0c('0x44')](Z - X) === a0;
+                }
+                [a0c('0x3e')]() {
+                    const W = this[a0c('0x15')](0x9);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers'](), Y = X['B'] + X['C'] + X['D'];
+                    switch (W) {
+                    case 'A':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x5,
+                            0x7
+                        ]['indexOf'](Y);
+                    case 'B':
+                        return -0x1 !== [
+                            0x1,
+                            0x4,
+                            0x9
+                        ][a0c('0xc')](Y);
+                    case 'C':
+                        return -0x1 !== [
+                            0x1,
+                            0x8
+                        ][a0c('0xc')](Y);
+                    case 'D':
+                        return -0x1 !== [
+                            0x5,
+                            0xa
+                        ][a0c('0xc')](Y);
+                    case 'E':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x6
+                        ][a0c('0xc')](Y);
+                    }
+                }
+                ['validateQ10']() {
+                    return !!this[a0c('0x15')](0xa) || null;
+                }
+            },
+            'srq-2': class extends B {
+                constructor() {
+                    super(), H(this, a0c('0x43'), a0c('0x53')[a0c('0x19')]('')), H(this, 'TOTAL_ANSWERS', 0x5), H(this, a0c('0x5d'), 0xa);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this['validateQ1'](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this[a0c('0x40')](),
+                        this[a0c('0xa')](),
+                        this['validateQ9'](),
+                        this[a0c('0x4')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x8,
+                        0x7,
+                        0x6,
+                        0x5,
+                        0x4
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('D') === X - 0x1;
+                }
+                ['validateQ2']() {
+                    const W = this[a0c('0x15')](0x2);
+                    return W ? this['consecutives']()[this[a0c('0x2a')](W, [
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6
+                    ])] : null;
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    return W ? this['aggregateAnswers']()['E'] === this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]) : null;
+                }
+                ['validateQ4']() {
+                    const W = this['getAnswers'](0x4);
+                    return W ? this['aggregateAnswers']()['A'] === this['mapAnswerToValue'](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]) : null;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this[a0c('0x2a')](W, [
+                            'A',
+                            'B',
+                            'C',
+                            'D',
+                            'E'
+                        ]);
+                    return X['A'] === X[Y];
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x21')])(0x5, 0xa, 0x1)[a0c('0x3c')](a0 => this['getAnswers'](a0)), Y = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Z = X['lastIndexOf']('B');
+                    return -0x1 !== Z && Z === Y;
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this[a0c('0x15')](0x8);
+                    if (!Y)
+                        return !0x1;
+                    const Z = this[a0c('0x2a')](Y, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), a0 = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]);
+                    return Math['abs'](Z - X) === a0;
+                }
+                ['validateQ8']() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return W === this[a0c('0x15')](X);
+                }
+                ['validateQ9']() {
+                    const W = this[a0c('0x15')](0x9);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers']();
+                    return this[a0c('0x2a')](W, [
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6,
+                        0x7
+                    ]) === X['B'] + X['C'] + X['D'];
+                }
+                [a0c('0x4')]() {
+                    return !!this['getAnswers'](0xa) || null;
+                }
+            },
+            'srq-3': class extends B {
+                constructor() {
+                    super(), I(this, a0c('0x43'), 'ABCD'[a0c('0x19')]('')), I(this, 'TOTAL_ANSWERS', 0x4), I(this, 'TOTAL_QUESTIONS', 0xa);
+                }
+                ['validade']() {
+                    return [
+                        this[a0c('0x56')](),
+                        this['validateQ2'](),
+                        this['validateQ3'](),
+                        this['validateQ4'](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this['validateQ7'](),
+                        this[a0c('0xa')](),
+                        this['validateQ9'](),
+                        this['validateQ10']()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    return !!this[a0c('0x15')](0x1) || null;
+                }
+                ['validateQ2']() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x15')](0x1), Y = this['getAnswers'](0x3);
+                    if (!X || !Y)
+                        return !0x1;
+                    switch (W) {
+                    case 'A':
+                        return W === Y && W !== X;
+                    case 'B':
+                        return W === X && W !== Y;
+                    case 'C':
+                        return W === X && W === Y;
+                    case 'D':
+                        return W !== X && W !== Y;
+                    }
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    return W ? this['mapAnswerToValue'](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3
+                    ]) === this[a0c('0x2b')]()['A'] : null;
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3
+                        ]), Y = this[a0c('0xb')]();
+                    return X === Object(y[a0c('0x24')])(Y, Z => Z)[a0c('0x5c')];
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x15')](0x4);
+                    return !!X && this[a0c('0x2a')](W, [
+                        'C',
+                        'B',
+                        'A',
+                        'D'
+                    ]) === X;
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    return W ? 0x0 === this[a0c('0x2b')]()[this[a0c('0x2a')](W, [
+                        'A',
+                        'C',
+                        'D',
+                        'B'
+                    ])] : null;
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    return W ? 'B' === W : null;
+                }
+                [a0c('0xa')]() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x2,
+                        0x4
+                    ]);
+                    return this[a0c('0x2b')]()[W] - 0x1 === X;
+                }
+                ['validateQ9']() {
+                    const W = this['getAnswers'](0x9);
+                    if (!W)
+                        return null;
+                    switch (W) {
+                    case 'A':
+                        return !0x0;
+                    case 'B':
+                        return !0x1;
+                    case 'C':
+                        return !0x0;
+                    case 'D':
+                        return !0x1;
+                    }
+                }
+                ['validateQ10']() {
+                    const W = this[a0c('0x15')](0xa);
+                    return W ? 'D' !== W : null;
+                }
+            },
+            'simple-srq-1': class extends B {
+                constructor() {
+                    super(), J(this, 'ANSWERS_LETTERS', 'ABCD'[a0c('0x19')]('')), J(this, a0c('0x67'), 0x4), J(this, a0c('0x5d'), 0x5);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this['validateQ1'](),
+                        this['validateQ2'](),
+                        this['validateQ3'](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    return W ? 0x1 === this[a0c('0x2b')]()[W] : null;
+                }
+                ['validateQ2']() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this[a0c('0x2a')](W, [
+                            0x3,
+                            0x1,
+                            0x5,
+                            0x4
+                        ]);
+                    return W === this[a0c('0x15')](Y) && 0x2 === X[W];
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    return W ? this[a0c('0x2a')](W, [
+                        'B',
+                        'D',
+                        'A',
+                        'C'
+                    ]) === this[a0c('0x15')](0x5) : null;
+                }
+                [a0c('0x10')]() {
+                    const W = this['getAnswers'](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('A') === X - 0x1;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    return W ? this['mapAnswerToValue'](W, [
+                        'C',
+                        'B',
+                        'D',
+                        'A'
+                    ]) === this['getAnswers'](0x3) : null;
+                }
+            },
+            'simple-srq-2': class extends B {
+                constructor() {
+                    super(), K(this, a0c('0x43'), 'ABCDE'[a0c('0x19')]('')), K(this, a0c('0x67'), 0x5), K(this, a0c('0x5d'), 0xa);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this[a0c('0x40')](),
+                        this[a0c('0xa')](),
+                        this[a0c('0x3e')](),
+                        this[a0c('0x4')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    return !!this[a0c('0x15')](0x1) || null;
+                }
+                [a0c('0x50')]() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this[a0c('0x2a')](W, [
+                            'B',
+                            'C',
+                            'D',
+                            'E',
+                            'A'
+                        ]);
+                    return 'E' === W ? X['A'] === X['B'] && X['A'] === X['C'] && X['A'] === X['D'] && X['A'] === X['E'] : X['A'] === X[Y];
+                }
+                [a0c('0x65')]() {
+                    const W = this['getAnswers'](0x3);
+                    return W ? this[a0c('0x2a')](W, [
+                        'E',
+                        'D',
+                        'C',
+                        'B',
+                        'A'
+                    ]) === this[a0c('0x15')](0xa) : null;
+                }
+                ['validateQ4']() {
+                    const W = this[a0c('0x15')](0x4);
+                    return W ? this[a0c('0x2a')](W, [
+                        'A',
+                        'B',
+                        'C',
+                        'D',
+                        'E'
+                    ]) === this['getAnswers'](0x6) : null;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6,
+                        0x7
+                    ]);
+                    return W === this[a0c('0x15')](X);
+                }
+                [a0c('0x5f')]() {
+                    const W = this['getAnswers'](0x6);
+                    if (!W)
+                        return null;
+                    const X = this['mapAnswerToValue'](W, [
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6,
+                        0x7
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('B') === X - 0x1;
+                }
+                ['validateQ7']() {
+                    const W = this[a0c('0x15')](0x7);
+                    return W ? this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === this[a0c('0x2b')]()['C'] : null;
+                }
+                [a0c('0xa')]() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this[a0c('0x15')](0x9);
+                    if (!Y)
+                        return !0x1;
+                    const Z = this['mapAnswerToValue'](Y, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), a0 = this['mapAnswerToValue'](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]);
+                    return Math[a0c('0x44')](Z - X) === a0;
+                }
+                [a0c('0x3e')]() {
+                    const W = this[a0c('0x15')](0x9);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers'](), Y = X['A'] + X['E'];
+                    switch (W) {
+                    case 'A':
+                        return -0x1 !== [
+                            0x0,
+                            0x2,
+                            0x4,
+                            0x6,
+                            0x8,
+                            0xa
+                        ][a0c('0xc')](Y);
+                    case 'B':
+                        return -0x1 !== [
+                            0x1,
+                            0x3,
+                            0x5,
+                            0x7,
+                            0x9
+                        ][a0c('0xc')](Y);
+                    case 'C':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x5,
+                            0x7
+                        ][a0c('0xc')](Y);
+                    case 'D':
+                        return -0x1 !== [
+                            0x1,
+                            0x4,
+                            0x9
+                        ][a0c('0xc')](Y);
+                    case 'E':
+                        return -0x1 !== [
+                            0x5,
+                            0xa
+                        ]['indexOf'](Y);
+                    }
+                }
+                ['validateQ10']() {
+                    const W = this[a0c('0x15')](0xa);
+                    return W ? this[a0c('0x2a')](W, [
+                        'C',
+                        'D',
+                        'A',
+                        'B',
+                        'E'
+                    ]) === this['getAnswers'](0x3) : null;
+                }
+            },
+            'simple-srq-3': class extends B {
+                constructor() {
+                    super(), L(this, a0c('0x43'), 'ABCDE'[a0c('0x19')]('')), L(this, a0c('0x67'), 0x5), L(this, a0c('0x5d'), 0x5);
+                }
+                ['validade']() {
+                    return [
+                        this['validateQ1'](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    if ('E' === W) {
+                        return 0x0 == this[a0c('0x2b')]()['A'];
+                    }
+                    {
+                        const X = Object(y[a0c('0x21')])(0x2, 0x6, 0x1)[a0c('0x3c')](Y => this[a0c('0x15')](Y))[a0c('0xc')]('A');
+                        return this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3
+                        ]) === X;
+                    }
+                }
+                [a0c('0x50')]() {
+                    const W = this['getAnswers'](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ]), Y = this[a0c('0x2b')]();
+                    return X === Y['A'] + Y['E'];
+                }
+                [a0c('0x65')]() {
+                    const W = this['getAnswers'](0x3);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            [
+                                0x2,
+                                0x5
+                            ],
+                            [
+                                0x2,
+                                0x4
+                            ],
+                            [
+                                0x1,
+                                0x3
+                            ],
+                            [
+                                0x1,
+                                0x4
+                            ],
+                            [
+                                0x3,
+                                0x5
+                            ]
+                        ]), Y = this[a0c('0x2b')](), Z = this[a0c('0x15')](X[0x0]), a0 = this[a0c('0x15')](X[0x1]);
+                    return 'C' === Z && 'C' === a0 && 0x2 === Y['C'];
+                }
+                [a0c('0x10')]() {
+                    const W = this['getAnswers'](0x4);
+                    return W ? this['mapAnswerToValue'](W, [
+                        'A',
+                        'C',
+                        'B',
+                        'D',
+                        'E'
+                    ]) === this[a0c('0x15')](0x5) : null;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    return W ? this[a0c('0x2a')](W, [
+                        'A',
+                        'C',
+                        'D',
+                        'B',
+                        'E'
+                    ]) === this[a0c('0x15')](0x4) : null;
+                }
+            },
+            'simple-srq-4': class extends B {
+                constructor() {
+                    super(), M(this, a0c('0x43'), 'ABCDE'[a0c('0x19')]('')), M(this, a0c('0x67'), 0x5), M(this, a0c('0x5d'), 0x6);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this['validateQ4'](),
+                        this[a0c('0x5')](),
+                        this['validateQ6']()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this['getAnswers'](0x1);
+                    return W ? this['mapAnswerToValue'](W, [
+                        'E',
+                        'D',
+                        'C',
+                        'B',
+                        'A'
+                    ]) === this[a0c('0x15')](0x2) : null;
+                }
+                ['validateQ2']() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ]), Y = this[a0c('0x15')](X), Z = Object(y[a0c('0x24')])([
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ], a0 => 'C' === this[a0c('0x15')](a0));
+                    return 'C' === Y && 0x1 === Z['length'];
+                }
+                [a0c('0x65')]() {
+                    return !!this[a0c('0x15')](0x3) || null;
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return this[a0c('0x2b')]()['B'] === X;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0xb')]();
+                    return X[this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ])] && 0x1 === X[a0c('0x24')](Y => Y)[a0c('0x5c')];
+                }
+                ['validateQ6']() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return W === this['getAnswers'](X);
+                }
+            },
+            'srat': class extends B {
+                constructor() {
+                    super(), N(this, 'ANSWERS_LETTERS', a0c('0x53')[a0c('0x19')]('')), N(this, a0c('0x67'), 0x5), N(this, a0c('0x5d'), 0x14);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this['validateQ2'](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this[a0c('0x40')](),
+                        this[a0c('0xa')](),
+                        this[a0c('0x3e')](),
+                        this['validateQ10'](),
+                        this['validateQ11'](),
+                        this[a0c('0x1')](),
+                        this[a0c('0x5e')](),
+                        this[a0c('0x25')](),
+                        this[a0c('0x8')](),
+                        this['validateQ16'](),
+                        this[a0c('0xf')](),
+                        this[a0c('0x60')](),
+                        this[a0c('0x6')](),
+                        this[a0c('0x32')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('B') === X - 0x1;
+                }
+                ['validateQ2']() {
+                    const W = this['getAnswers'](0x2);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0xb')](), Y = 0x1 === Object(y[a0c('0x24')])(X, a0 => a0)[a0c('0x5c')], Z = this['mapAnswerToValue'](W, [
+                            0x5,
+                            0x6,
+                            0x7,
+                            0x8,
+                            0x9
+                        ]);
+                    return Y && X[Z];
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]()['E'];
+                    return this['mapAnswerToValue'](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === X;
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers']()['A'];
+                    return this[a0c('0x2a')](W, [
+                        0x4,
+                        0x5,
+                        0x6,
+                        0x7,
+                        0x8
+                    ]) === X;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5
+                    ]);
+                    return W === this[a0c('0x15')](X);
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = this['getAnswers'](0x11);
+                    switch (W) {
+                    case 'D':
+                        if ('C' !== X && 'D' !== X && 'E' !== X)
+                            return !0x0;
+                    case 'E':
+                        return !0x1;
+                    default:
+                        return this[a0c('0x2a')](W, [
+                            'C',
+                            'D',
+                            'E',
+                            'A',
+                            'B'
+                        ]) === X;
+                    }
+                }
+                ['validateQ7']() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = this['mapAnswerToValue'](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this[a0c('0x15')](0x8);
+                    if (!Y)
+                        return !0x1;
+                    const Z = this['mapAnswerToValue'](Y, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), a0 = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]);
+                    return Math[a0c('0x44')](Z - X) === a0;
+                }
+                [a0c('0xa')]() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x5,
+                            0x6,
+                            0x7,
+                            0x8
+                        ]), Y = this[a0c('0x2b')]();
+                    return X === Y['A'] + Y['E'];
+                }
+                [a0c('0x3e')]() {
+                    const W = this[a0c('0x15')](0x9);
+                    if (!W)
+                        return null;
+                    const X = Object(y['range'])(0xa, 0xf, 0x1)[a0c('0x3c')](Y => this[a0c('0x15')](Y))[a0c('0xc')](W);
+                    return this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === X;
+                }
+                ['validateQ10']() {
+                    const W = this[a0c('0x15')](0xa);
+                    return W ? this[a0c('0x2a')](W, [
+                        'D',
+                        'A',
+                        'E',
+                        'B',
+                        'C'
+                    ]) === this[a0c('0x15')](0x10) : null;
+                }
+                [a0c('0x4e')]() {
+                    const W = this['getAnswers'](0xb);
+                    if (!W)
+                        return null;
+                    const X = Object(y['range'])(0x1, 0xb, 0x1)[a0c('0x3c')](Y => this['getAnswers'](Y));
+                    return this['mapAnswerToValue'](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === Object(y[a0c('0x24')])(X, Y => 'B' === Y)[a0c('0x5c')];
+                }
+                [a0c('0x1')]() {
+                    const W = this[a0c('0x15')](0xc);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = X['B'] + X['C'] + X['D'];
+                    switch (W) {
+                    case 'A':
+                        return -0x1 !== [
+                            0x0,
+                            0x2,
+                            0x4,
+                            0x6,
+                            0x8,
+                            0xa,
+                            0xc,
+                            0xe,
+                            0x10,
+                            0x12,
+                            0x14
+                        ][a0c('0xc')](Y);
+                    case 'B':
+                        return -0x1 !== [
+                            0x1,
+                            0x3,
+                            0x5,
+                            0x7,
+                            0x9,
+                            0xb,
+                            0xd,
+                            0xf,
+                            0x11,
+                            0x13
+                        ][a0c('0xc')](Y);
+                    case 'C':
+                        return -0x1 !== [
+                            0x1,
+                            0x4,
+                            0x9,
+                            0x10
+                        ]['indexOf'](Y);
+                    case 'D':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x5,
+                            0x7,
+                            0xb,
+                            0xd,
+                            0x11
+                        ]['indexOf'](Y);
+                    case 'E':
+                        return -0x1 !== [
+                            0x5,
+                            0xa,
+                            0xf,
+                            0x14
+                        ][a0c('0xc')](Y);
+                    }
+                }
+                [a0c('0x5e')]() {
+                    const W = this[a0c('0x15')](0xd);
+                    if (!W)
+                        return null;
+                    this['aggregateAnswers']();
+                    const X = this[a0c('0x2a')](W, [
+                            0x9,
+                            0xb,
+                            0xd,
+                            0xf,
+                            0x11
+                        ]), Y = this[a0c('0x15')](X), Z = Object(y[a0c('0x24')])([
+                            0x13,
+                            0x11,
+                            0xf,
+                            0xd,
+                            0xb,
+                            0x9,
+                            0x7,
+                            0x5,
+                            0x3,
+                            0x1
+                        ], a0 => 'A' === this[a0c('0x15')](a0));
+                    return 'A' === Y && 0x1 === Z[a0c('0x5c')];
+                }
+                [a0c('0x25')]() {
+                    const W = this[a0c('0x15')](0xe);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]()['D'];
+                    return this[a0c('0x2a')](W, [
+                        0x6,
+                        0x7,
+                        0x8,
+                        0x9,
+                        0xa
+                    ]) === X;
+                }
+                ['validateQ15']() {
+                    const W = this[a0c('0x15')](0xf);
+                    return W ? this[a0c('0x2a')](W, [
+                        'A',
+                        'B',
+                        'C',
+                        'D',
+                        'E'
+                    ]) === this[a0c('0x15')](0xc) : null;
+                }
+                [a0c('0x22')]() {
+                    const W = this[a0c('0x15')](0x10);
+                    return W ? this['mapAnswerToValue'](W, [
+                        'D',
+                        'C',
+                        'B',
+                        'A',
+                        'E'
+                    ]) === this[a0c('0x15')](0xa) : null;
+                }
+                [a0c('0xf')]() {
+                    const W = this[a0c('0x15')](0x11);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x15')](0x6);
+                    switch (W) {
+                    case 'D':
+                        if ('C' !== X && 'D' !== X && 'E' !== X)
+                            return !0x0;
+                    case 'E':
+                        return !0x1;
+                    default:
+                        return this[a0c('0x2a')](W, [
+                            'C',
+                            'D',
+                            'E',
+                            'A',
+                            'B'
+                        ]) === X;
+                    }
+                }
+                ['validateQ18']() {
+                    const W = this[a0c('0x15')](0x12);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this[a0c('0x2a')](W, [
+                            'B',
+                            'C',
+                            'D',
+                            'E',
+                            'A'
+                        ]);
+                    return 'E' === W ? X['A'] !== X['B'] && X['A'] !== X['C'] && X['A'] !== X['D'] && X['A'] !== X['E'] : X['A'] === X[Y];
+                }
+                [a0c('0x6')]() {
+                    return !!this[a0c('0x15')](0x13) || null;
+                }
+                [a0c('0x32')]() {
+                    const W = this[a0c('0x15')](0x14);
+                    return W ? 'E' === W : null;
+                }
+            },
+            'dont-be-puzzled': class extends B {
+                constructor() {
+                    super(), P(this, a0c('0x43'), a0c('0x53')[a0c('0x19')]('')), P(this, a0c('0x67'), 0x5), P(this, a0c('0x5d'), 0xa);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this['validateQ1'](),
+                        this['validateQ2'](),
+                        this[a0c('0x65')](),
+                        this[a0c('0x10')](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this[a0c('0x40')](),
+                        this[a0c('0xa')](),
+                        this['validateQ9'](),
+                        this['validateQ10']()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this[a0c('0x15')](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x1
+                        ]), Y = this['answers']['indexOf']('A');
+                    return 'E' === W ? Y > 0x3 || -0x1 === Y : Y === X - 0x1;
+                }
+                [a0c('0x50')]() {
+                    const W = this[a0c('0x15')](0x2);
+                    return W ? this['consecutives']()[this[a0c('0x2a')](W, [
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6
+                    ])] : null;
+                }
+                [a0c('0x65')]() {
+                    const W = this[a0c('0x15')](0x3);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x21')])(0x4, 0x9, 0x1)['map'](Y => this[a0c('0x15')](Y))[a0c('0xc')]('A');
+                    return this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === X;
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    [
+                        0x2,
+                        0x4,
+                        0x6,
+                        0x8,
+                        0xa
+                    ]['map'](Y => this[a0c('0x15')](Y));
+                    const X = this[a0c('0x2a')](W, [
+                        0x2,
+                        0x4,
+                        0x6,
+                        0x8,
+                        0xa
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('B') === X - 0x1;
+                }
+                [a0c('0x5')]() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    this[a0c('0x2b')]();
+                    const X = this['mapAnswerToValue'](W, [
+                            0x1,
+                            0x3,
+                            0x5,
+                            0x7,
+                            0x9
+                        ]), Y = this[a0c('0x15')](X), Z = Object(y[a0c('0x24')])([
+                            0x1,
+                            0x3,
+                            0x5,
+                            0x7,
+                            0x9
+                        ], a0 => 'C' === this[a0c('0x15')](a0));
+                    return 'C' === Y && 0x1 === Z[a0c('0x5c')];
+                }
+                [a0c('0x5f')]() {
+                    const W = this[a0c('0x15')](0x6);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x24')])([
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ], a1 => 'D' === this[a0c('0x15')](a1)), Y = Object(y['filter'])([
+                            0x7,
+                            0x8,
+                            0x9,
+                            0xa
+                        ], a1 => 'D' === this[a0c('0x15')](a1)), Z = X[a0c('0x5c')] >= 0x1, a0 = Y[a0c('0x5c')] >= 0x1;
+                    switch (W) {
+                    case 'A':
+                        return Z && !a0;
+                    case 'B':
+                        return !Z && a0;
+                    case 'C':
+                        return Z && a0;
+                    case 'D':
+                    case 'E':
+                        return !0x1;
+                    }
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x21')])(0x5, 0xa, 0x1)['map'](a0 => this[a0c('0x15')](a0)), Y = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Z = X[a0c('0x3f')]('E');
+                    return -0x1 !== Z && Z === Y;
+                }
+                ['validateQ8']() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this['aggregateAnswers']();
+                    return this[a0c('0x2a')](W, [
+                        0x7,
+                        0x6,
+                        0x5,
+                        0x4,
+                        0x3
+                    ]) === X['B'] + X['C'] + X['D'];
+                }
+                [a0c('0x3e')]() {
+                    const W = this['getAnswers'](0x9);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this[a0c('0x2b')]();
+                    return X === Y['A'] + Y['E'];
+                }
+                [a0c('0x4')]() {
+                    return !!this[a0c('0x15')](0xa) || null;
+                }
+            },
+            'small-srat': class extends B {
+                constructor() {
+                    super(), R(this, a0c('0x43'), 'ABCDE'[a0c('0x19')]('')), R(this, a0c('0x67'), 0x5), R(this, a0c('0x5d'), 0xa);
+                }
+                [a0c('0x58')]() {
+                    return [
+                        this[a0c('0x56')](),
+                        this[a0c('0x50')](),
+                        this[a0c('0x65')](),
+                        this['validateQ4'](),
+                        this[a0c('0x5')](),
+                        this[a0c('0x5f')](),
+                        this[a0c('0x40')](),
+                        this[a0c('0xa')](),
+                        this[a0c('0x3e')](),
+                        this[a0c('0x4')]()
+                    ];
+                }
+                [a0c('0x56')]() {
+                    const W = this['getAnswers'](0x1);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0x2,
+                        0x3,
+                        0x4,
+                        0x5,
+                        0x6
+                    ]);
+                    return this[a0c('0x41')][a0c('0xc')]('B') === X - 0x1;
+                }
+                ['validateQ2']() {
+                    const W = this[a0c('0x15')](0x2);
+                    if (!W)
+                        return null;
+                    const X = this['consecutives'](), Y = 0x1 === Object(y[a0c('0x24')])(X, a0 => a0)[a0c('0x5c')], Z = this[a0c('0x2a')](W, [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5
+                        ]);
+                    return Y && X[Z];
+                }
+                ['validateQ3']() {
+                    const W = this[a0c('0x15')](0x3);
+                    if (!W)
+                        return null;
+                    const X = Object(y[a0c('0x21')])(0x6, 0xb, 0x1)[a0c('0x3c')](a0 => this[a0c('0x15')](a0)), Y = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]), Z = X[a0c('0x3f')](W);
+                    return -0x1 !== Z && Z === Y;
+                }
+                [a0c('0x10')]() {
+                    const W = this[a0c('0x15')](0x4);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')]()['A'];
+                    return this[a0c('0x2a')](W, [
+                        0x0,
+                        0x1,
+                        0x2,
+                        0x3,
+                        0x4
+                    ]) === X;
+                }
+                ['validateQ5']() {
+                    const W = this[a0c('0x15')](0x5);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                        0xa,
+                        0x9,
+                        0x8,
+                        0x7,
+                        0x6
+                    ]);
+                    return W === this[a0c('0x15')](X);
+                }
+                ['validateQ6']() {
+                    const W = this['getAnswers'](0x6);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = this['mapAnswerToValue'](W, [
+                            'B',
+                            'C',
+                            'D',
+                            'E',
+                            'A'
+                        ]);
+                    return 'E' === W ? X['A'] !== X['B'] && X['A'] !== X['C'] && X['A'] !== X['D'] && X['A'] !== X['E'] : X['A'] === X[Y];
+                }
+                [a0c('0x40')]() {
+                    const W = this[a0c('0x15')](0x7);
+                    if (!W)
+                        return null;
+                    const X = this['mapAnswerToValue'](W, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), Y = this['getAnswers'](0x8);
+                    if (!Y)
+                        return !0x1;
+                    const Z = this[a0c('0x2a')](Y, [
+                            0x0,
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x4
+                        ]), a0 = this[a0c('0x2a')](W, [
+                            0x4,
+                            0x3,
+                            0x2,
+                            0x1,
+                            0x0
+                        ]);
+                    return Math[a0c('0x44')](Z - X) === a0;
+                }
+                [a0c('0xa')]() {
+                    const W = this[a0c('0x15')](0x8);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2a')](W, [
+                            0x2,
+                            0x3,
+                            0x4,
+                            0x5,
+                            0x6
+                        ]), Y = this[a0c('0x2b')]();
+                    return X === Y['A'] + Y['E'];
+                }
+                [a0c('0x3e')]() {
+                    const W = this[a0c('0x15')](0x9);
+                    if (!W)
+                        return null;
+                    const X = this[a0c('0x2b')](), Y = X['B'] + X['C'] + X['D'];
+                    switch (W) {
+                    case 'A':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x3,
+                            0x5,
+                            0x7
+                        ][a0c('0xc')](Y);
+                    case 'B':
+                        return -0x1 !== [
+                            0x1,
+                            0x2,
+                            0x6
+                        ][a0c('0xc')](Y);
+                    case 'C':
+                        return -0x1 !== [
+                            0x1,
+                            0x4,
+                            0x9
+                        ]['indexOf'](Y);
+                    case 'D':
+                        return -0x1 !== [
+                            0x1,
+                            0x8
+                        ][a0c('0xc')](Y);
+                    case 'E':
+                        return -0x1 !== [
+                            0x5,
+                            0xa
+                        ]['indexOf'](Y);
+                    }
+                }
+                [a0c('0x4')]() {
+                    return !!this[a0c('0x15')](0xa) || null;
+                }
+            }
+        };
+        class U {
+            constructor(W) {
+                this['won'] = !0x1, this[a0c('0x5b')] = W, this['$questions'] = x()('div[data-question]'), this[a0c('0x3')]();
+                const X = new S[this[(a0c('0x5b'))]['slug']]();
+                this[a0c('0x48')] = X, this[a0c('0x4d')] = Object(y[a0c('0x21')])(X[a0c('0x5d')])['map'](() => Object(y[a0c('0x21')])(X[a0c('0x67')])[a0c('0x3c')](() => null));
+            }
+            [a0c('0x49')](W, X) {
+                const {answers_state: Y} = this;
+                return !0x0 === Y[W][X] || !Object(y[a0c('0x37')])(Y[W]);
+            }
+            [a0c('0x9')](W, X) {
+                if (!this[a0c('0x49')](W, X))
+                    return;
+                const {answers_state: Y} = this;
+                Y[W][X] = {
+                    'null': !0x1,
+                    'true': null,
+                    'false': !0x0
+                }[Y[W][X]];
+            }
+            [a0c('0x23')](W, X) {
+                this[a0c('0x9')](W, X), this[a0c('0x28')]();
+            }
+            [a0c('0x28')]() {
+                const W = this[a0c('0x15')]();
+                this[a0c('0x48')][a0c('0x28')](W);
+                const X = this[a0c('0x48')]['validade']();
+                this[a0c('0x57')](X), Object(y[a0c('0x17')])(X) && !this[a0c('0x61')] && (this[a0c('0x61')] = !0x0, z['a'][a0c('0x34')](), amplitude['getInstance']()['logEvent'](a0c('0x5a'), { 'slug': puzzle['slug'] }));
+            }
+            [a0c('0x57')](W) {
+                Object(y[a0c('0x2')])(this[a0c('0x3b')], (X, Y) => {
+                    const Z = x()(X);
+                    Z[a0c('0x13')]('correct\x20wrong');
+                    const a0 = W[Y];
+                    null !== a0 && Z[a0c('0x2f')](a0 ? a0c('0x2c') : a0c('0x51'));
+                }), Object(y[a0c('0x2')])(this[a0c('0x3b')], (X, Y) => {
+                    const Z = x()(X)[a0c('0x11')](a0c('0x45')), a0 = Object(y['some'])(this[a0c('0x4d')][Y]);
+                    Object(y['forEach'])(Z, (a1, a2) => {
+                        const a3 = x()(a1);
+                        a3['removeClass']();
+                        const a4 = this[a0c('0x4d')][Y][a2];
+                        !0x0 === a4 ? a3[a0c('0x2f')](a0c('0x2c')) : ((!0x1 === a4 || a0) && a3['addClass'](a0c('0x51')), a0 && a3[a0c('0x2f')](a0c('0x20')));
+                    });
+                });
+            }
+            [a0c('0x3')]() {
+                this[a0c('0x3b')]['on']('click', a0c('0x45'), W => {
+                    const X = x()(W['currentTarget']);
+                    this['onClick'](X[a0c('0x59')]('question'), X[a0c('0x59')](a0c('0x55')));
+                });
+            }
+            [a0c('0x15')]() {
+                return this['answers_state']['map'](W => {
+                    const X = W[a0c('0xc')](!0x0);
+                    return -0x1 != X ? this[a0c('0x48')][a0c('0x43')][X] : null;
+                });
+            }
+        }
+        let V = null;
+        window[a0c('0x1b')] = W => {
+            V = new U(W);
+        };
+    },
+    16: function (b, c) {
+        var f;
+        f = function () {
+            return this;
+        }();
+        try {
+            f = f || new Function(a0c('0x62'))();
+        } catch (g) {
+            a0c('0x3d') == typeof window && (f = window);
+        }
+        b[a0c('0x1c')] = f;
+    },
+    21: function (b, c, f) {
+        'use strict';
+        f['d'](c, 'b', function () {
+            return j;
+        }), f['d'](c, 'a', function () {
+            return k;
+        });
+        var g = f(0x3);
+        function h(l, m, o) {
+            return m in l ? Object['defineProperty'](l, m, {
+                'value': o,
+                'enumerable': !0x0,
+                'configurable': !0x0,
+                'writable': !0x0
+            }) : l[m] = o, l;
+        }
+        class j {
+            constructor(l) {
+                h(this, a0c('0x4b'), void 0x0), h(this, a0c('0x39'), void 0x0), this['$div'] = l, this['$overlay'] = $('\x0a\x20\x20\x20\x20\x20\x20<div\x20class=\x22overlay-endgame\x22>\x0a\x20\x20\x20\x20\x20\x20\x20\x20<div\x20class=\x22brand-wrapper\x22>\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20<div\x20class=\x22brand\x22></div>\x0a\x20\x20\x20\x20\x20\x20\x20\x20</div>\x0a\x20\x20\x20\x20\x20\x20</div>');
+            }
+            [a0c('0x7')]() {
+                return this[a0c('0x4b')]['append'](this['$overlay']);
+            }
+            ['hide']() {
+                return this[a0c('0x39')][a0c('0xe')]();
+            }
+        }
+        class k {
+            static ['modalBase'](l, m) {
+                const o = $(a0c('0x64')[a0c('0x38')](l));
+                if (o['data'](a0c('0x35'))) {
+                    const p = o[a0c('0x11')](a0c('0xd')), q = $('#templateBody-'[a0c('0x38')](l)), u = Object(g[a0c('0x29')])(q[0x0][a0c('0x12')]);
+                    p[a0c('0x16')](u(m));
+                }
+                return o['modal'](a0c('0x7'));
+            }
+            static [a0c('0x34')](l) {
+                const m = this['modalBase']('end-game', l);
+                return new Promise(o => {
+                    m['on']('hidden.bs.modal', () => o());
+                });
+            }
+        }
+    },
+    24: function (b, c) {
+        b[a0c('0x1c')] = function (f) {
+            return f['webpackPolyfill'] || (f['deprecate'] = function () {
+            }, f['paths'] = [], f[a0c('0x46')] || (f[a0c('0x46')] = []), Object[a0c('0x27')](f, 'loaded', {
+                'enumerable': !0x0,
+                'get': function () {
+                    return f['l'];
+                }
+            }), Object[a0c('0x27')](f, 'id', {
+                'enumerable': !0x0,
+                'get': function () {
+                    return f['i'];
+                }
+            }), f[a0c('0x63')] = 0x1), f;
+        };
+    }
+});
+console[a0c('0x0')](0x1);

+ 1308 - 0
test.js

@@ -0,0 +1,1308 @@
+!function (t) {
+    function e(e) {
+        for (var n, a, l = e[0], u = e[1], h = e[2], c = 0, A = []; c < l.length; c++) a = l[c], Object.prototype.hasOwnProperty.call(r, a) && r[a] && A.push(r[a][0]), r[a] = 0;
+        for (n in u) Object.prototype.hasOwnProperty.call(u, n) && (t[n] = u[n]);
+        for (o && o(e); A.length;) A.shift()();
+        return i.push.apply(i, h || []), s()
+    }
+
+    function s() {
+        for (var t, e = 0; e < i.length; e++) {
+            for (var s = i[e], n = !0, l = 1; l < s.length; l++) {
+                var u = s[l];
+                0 !== r[u] && (n = !1)
+            }
+            n && (i.splice(e--, 1), t = a(a.s = s[0]))
+        }
+        return t
+    }
+
+    var n = {}, r = {22: 0}, i = [];
+
+    function a(e) {
+        if (n[e]) return n[e].exports;
+        var s = n[e] = {i: e, l: !1, exports: {}};
+        return t[e].call(s.exports, s, s.exports, a), s.l = !0, s.exports
+    }
+
+    a.m = t, a.c = n, a.d = function (t, e, s) {
+        a.o(t, e) || Object.defineProperty(t, e, {enumerable: !0, get: s})
+    }, a.r = function (t) {
+        "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, {value: "Module"}), Object.defineProperty(t, "__esModule", {value: !0})
+    }, a.t = function (t, e) {
+        if (1 & e && (t = a(t)), 8 & e) return t;
+        if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+        var s = Object.create(null);
+        if (a.r(s), Object.defineProperty(s, "default", {
+            enumerable: !0,
+            value: t
+        }), 2 & e && "string" != typeof t) for (var n in t) a.d(s, n, function (e) {
+            return t[e]
+        }.bind(null, n));
+        return s
+    }, a.n = function (t) {
+        var e = t && t.__esModule ? function () {
+            return t.default
+        } : function () {
+            return t
+        };
+        return a.d(e, "a", e), e
+    }, a.o = function (t, e) {
+        return Object.prototype.hasOwnProperty.call(t, e)
+    }, a.p = "";
+    var l = window.webpackJsonp = window.webpackJsonp || [], u = l.push.bind(l);
+    l.push = e, l = l.slice();
+    for (var h = 0; h < l.length; h++) e(l[h]);
+    var o = u;
+    i.push([153, 0]), s()
+}({
+    153: function (t, e, s) {
+        "use strict";
+        s.r(e);
+        var n = s(25), r = s.n(n), i = s(3), a = s(21);
+
+        class l {
+            constructor() {
+                var t, e, s;
+                s = {
+                    A: 0,
+                    B: 1,
+                    C: 2,
+                    D: 3,
+                    E: 4
+                }, (e = "ANSWERS_LETTERS_TO_INDEX") in (t = this) ? Object.defineProperty(t, e, {
+                    value: s,
+                    enumerable: !0,
+                    configurable: !0,
+                    writable: !0
+                }) : t[e] = s
+            }
+
+            update(t) {
+                this.answers = t
+            }
+
+            getAnswers(t) {
+                return this.answers[t - 1]
+            }
+
+            aggregateAnswers() {
+                const t = {};
+                return this.ANSWERS_LETTERS.forEach(e => t[e] = 0), this.answers.forEach(e => {
+                    e && (t[e] || (t[e] = 0), t[e]++)
+                }), t
+            }
+
+            mapAnswerToValue(t, e) {
+                return e[this.ANSWERS_LETTERS_TO_INDEX[t]]
+            }
+
+            consecutives() {
+                const t = [], e = this.answers;
+                for (var s = 0; s < e.length - 1; s++) t.push(!(e[s] !== e[s + 1] || !e[s]));
+                return t
+            }
+        }
+
+        function u(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function h(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function o(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function c(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function A(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function d(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function w(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function g(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function v(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function f(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function Q(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function p(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        function T(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        const m = {
+            "basic-1": class extends l {
+                constructor() {
+                    super(), u(this, "ANSWERS_LETTERS", "ABCD".split("")), u(this, "TOTAL_ANSWERS", 4), u(this, "TOTAL_QUESTIONS", 3)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    return t ? t === this.getAnswers(2) : null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    return t ? this.aggregateAnswers().B == this.mapAnswerToValue(t, [0, 1, 2, 3]) : null
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.aggregateAnswers().A == this.mapAnswerToValue(t, [0, 1, 2, 3]) : null
+                }
+            }, "basic-2": class extends l {
+                constructor() {
+                    super(), h(this, "ANSWERS_LETTERS", "ABCDE".split("")), h(this, "TOTAL_ANSWERS", 5), h(this, "TOTAL_QUESTIONS", 4)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    return t ? this.aggregateAnswers().A == this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) : null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, -1]);
+                    if ("E" === t) {
+                        return 0 == this.aggregateAnswers().A
+                    }
+                    return this.answers.indexOf("A") === e - 1
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.mapAnswerToValue(t, ["C", "D", "E", "A", "B"]) === this.getAnswers(2) : null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, ["C", "B", "A", "E", "D"]),
+                        n = 1 === Object(i.filter)(e, t => t >= 2).length;
+                    return e[s] >= 2 && n
+                }
+            }, "the-incredible-eight": class extends l {
+                constructor() {
+                    super(), o(this, "ANSWERS_LETTERS", "ABCD".split("")), o(this, "TOTAL_ANSWERS", 4), o(this, "TOTAL_QUESTIONS", 8)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers().C;
+                    return this.mapAnswerToValue(t, [1, 2, 3, 4]) === e
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, ["D", "B", "C", "A"]), s = this.aggregateAnswers(), n = s[e];
+                    return 3 == Object(i.filter)(s, (t, e) => t > n).length
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, ["D", "C", "B", "A"]), s = this.aggregateAnswers(), n = s[e];
+                    return 3 == Object(i.filter)(s, (t, e) => t < n).length
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers();
+                    switch (t) {
+                        case"A":
+                            return 4 === e.A;
+                        case"B":
+                            return 1 === e.A;
+                        case"C":
+                            return 0 === e.B;
+                        case"D":
+                            return e.A === e.C
+                    }
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [5, 6, 7, 1]);
+                    return this.answers.indexOf("A") === e - 1
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers();
+                    return Object(i.map)(e, (t, e) => t).sort().reverse()[0] === this.mapAnswerToValue(t, [3, 4, 5, 6])
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = [], s = this.answers;
+                    for (var n = 0; n < s.length - 1; n++) e.push(!(s[n] !== s[n + 1] || !s[n]));
+                    const r = 1 === Object(i.filter)(e, t => t).length, a = this.mapAnswerToValue(t, [1, 6, 0, 3]);
+                    return r && e[a]
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, [4, 2, 3, 7]);
+                    return t === this.getAnswers(s) && 2 === e[t]
+                }
+            }, "srq-1": class extends l {
+                constructor() {
+                    super(), c(this, "ANSWERS_LETTERS", "ABCDE".split("")), c(this, "TOTAL_ANSWERS", 5), c(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return this.answers.indexOf("E") === e - 1
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    this.aggregateAnswers();
+                    const e = this.mapAnswerToValue(t, [9, 7, 5, 3, 1]), s = this.getAnswers(e),
+                        n = Object(i.filter)([9, 7, 5, 3, 1], t => "B" === this.getAnswers(t));
+                    return "B" === s && 1 === n.length
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = this.consecutives(), s = 1 === Object(i.filter)(e, t => t).length,
+                        n = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return s && e[n]
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    this.aggregateAnswers();
+                    const e = this.mapAnswerToValue(t, [2, 4, 6, 8, 10]), s = this.getAnswers(e),
+                        n = Object(i.filter)([2, 4, 6, 8, 10], t => "A" === this.getAnswers(t));
+                    return "A" === s && 1 === n.length
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    return t ? this.aggregateAnswers().B === this.mapAnswerToValue(t, [5, 4, 3, 2, 1]) : null
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = Object(i.range)(1, 10, 2).map(t => this.getAnswers(t)),
+                        s = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), n = e.lastIndexOf(t);
+                    return -1 !== n && n === s
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return t === this.getAnswers(e)
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.getAnswers(9);
+                    if (!s) return !1;
+                    const n = this.mapAnswerToValue(s, [0, 1, 2, 3, 4]), r = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]);
+                    return Math.abs(n - e) === r
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = e.B + e.C + e.D;
+                    switch (t) {
+                        case"A":
+                            return -1 !== [1, 2, 3, 5, 7].indexOf(s);
+                        case"B":
+                            return -1 !== [1, 4, 9].indexOf(s);
+                        case"C":
+                            return -1 !== [1, 8].indexOf(s);
+                        case"D":
+                            return -1 !== [5, 10].indexOf(s);
+                        case"E":
+                            return -1 !== [1, 2, 6].indexOf(s)
+                    }
+                }
+
+                validateQ10() {
+                    return !!this.getAnswers(10) || null
+                }
+            }, "srq-2": class extends l {
+                constructor() {
+                    super(), A(this, "ANSWERS_LETTERS", "ABCDE".split("")), A(this, "TOTAL_ANSWERS", 5), A(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [8, 7, 6, 5, 4]);
+                    return this.answers.indexOf("D") === e - 1
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    return t ? this.consecutives()[this.mapAnswerToValue(t, [2, 3, 4, 5, 6])] : null
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.aggregateAnswers().E === this.mapAnswerToValue(t, [1, 2, 3, 4, 5]) : null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    return t ? this.aggregateAnswers().A === this.mapAnswerToValue(t, [1, 2, 3, 4, 5]) : null
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, ["A", "B", "C", "D", "E"]);
+                    return e.A === e[s]
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = Object(i.range)(5, 10, 1).map(t => this.getAnswers(t)),
+                        s = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), n = e.lastIndexOf("B");
+                    return -1 !== n && n === s
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.getAnswers(8);
+                    if (!s) return !1;
+                    const n = this.mapAnswerToValue(s, [0, 1, 2, 3, 4]), r = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]);
+                    return Math.abs(n - e) === r
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return t === this.getAnswers(e)
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers();
+                    return this.mapAnswerToValue(t, [3, 4, 5, 6, 7]) === e.B + e.C + e.D
+                }
+
+                validateQ10() {
+                    return !!this.getAnswers(10) || null
+                }
+            }, "srq-3": class extends l {
+                constructor() {
+                    super(), d(this, "ANSWERS_LETTERS", "ABCD".split("")), d(this, "TOTAL_ANSWERS", 4), d(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    return !!this.getAnswers(1) || null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.getAnswers(1), s = this.getAnswers(3);
+                    if (!e || !s) return !1;
+                    switch (t) {
+                        case"A":
+                            return t === s && t !== e;
+                        case"B":
+                            return t === e && t !== s;
+                        case"C":
+                            return t === e && t === s;
+                        case"D":
+                            return t !== e && t !== s
+                    }
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.mapAnswerToValue(t, [0, 1, 2, 3]) === this.aggregateAnswers().A : null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3]), s = this.consecutives();
+                    return e === Object(i.filter)(s, t => t).length
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.getAnswers(4);
+                    return !!e && this.mapAnswerToValue(t, ["C", "B", "A", "D"]) === e
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    return t ? 0 === this.aggregateAnswers()[this.mapAnswerToValue(t, ["A", "C", "D", "B"])] : null
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    return t ? "B" === t : null
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 2, 4]);
+                    return this.aggregateAnswers()[t] - 1 === e
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    switch (t) {
+                        case"A":
+                            return !0;
+                        case"B":
+                            return !1;
+                        case"C":
+                            return !0;
+                        case"D":
+                            return !1
+                    }
+                }
+
+                validateQ10() {
+                    const t = this.getAnswers(10);
+                    return t ? "D" !== t : null
+                }
+            }, "simple-srq-1": class extends l {
+                constructor() {
+                    super(), w(this, "ANSWERS_LETTERS", "ABCD".split("")), w(this, "TOTAL_ANSWERS", 4), w(this, "TOTAL_QUESTIONS", 5)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    return t ? 1 === this.aggregateAnswers()[t] : null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, [3, 1, 5, 4]);
+                    return t === this.getAnswers(s) && 2 === e[t]
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.mapAnswerToValue(t, ["B", "D", "A", "C"]) === this.getAnswers(5) : null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [2, 3, 4, 5]);
+                    return this.answers.indexOf("A") === e - 1
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    return t ? this.mapAnswerToValue(t, ["C", "B", "D", "A"]) === this.getAnswers(3) : null
+                }
+            }, "simple-srq-2": class extends l {
+                constructor() {
+                    super(), g(this, "ANSWERS_LETTERS", "ABCDE".split("")), g(this, "TOTAL_ANSWERS", 5), g(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    return !!this.getAnswers(1) || null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, ["B", "C", "D", "E", "A"]);
+                    return "E" === t ? e.A === e.B && e.A === e.C && e.A === e.D && e.A === e.E : e.A === e[s]
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    return t ? this.mapAnswerToValue(t, ["E", "D", "C", "B", "A"]) === this.getAnswers(10) : null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    return t ? this.mapAnswerToValue(t, ["A", "B", "C", "D", "E"]) === this.getAnswers(6) : null
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [3, 4, 5, 6, 7]);
+                    return t === this.getAnswers(e)
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [3, 4, 5, 6, 7]);
+                    return this.answers.indexOf("B") === e - 1
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    return t ? this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === this.aggregateAnswers().C : null
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.getAnswers(9);
+                    if (!s) return !1;
+                    const n = this.mapAnswerToValue(s, [0, 1, 2, 3, 4]), r = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]);
+                    return Math.abs(n - e) === r
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = e.A + e.E;
+                    switch (t) {
+                        case"A":
+                            return -1 !== [0, 2, 4, 6, 8, 10].indexOf(s);
+                        case"B":
+                            return -1 !== [1, 3, 5, 7, 9].indexOf(s);
+                        case"C":
+                            return -1 !== [1, 2, 3, 5, 7].indexOf(s);
+                        case"D":
+                            return -1 !== [1, 4, 9].indexOf(s);
+                        case"E":
+                            return -1 !== [5, 10].indexOf(s)
+                    }
+                }
+
+                validateQ10() {
+                    const t = this.getAnswers(10);
+                    return t ? this.mapAnswerToValue(t, ["C", "D", "A", "B", "E"]) === this.getAnswers(3) : null
+                }
+            }, "simple-srq-3": class extends l {
+                constructor() {
+                    super(), v(this, "ANSWERS_LETTERS", "ABCDE".split("")), v(this, "TOTAL_ANSWERS", 5), v(this, "TOTAL_QUESTIONS", 5)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    if ("E" === t) {
+                        return 0 == this.aggregateAnswers().A
+                    }
+                    {
+                        const e = Object(i.range)(2, 6, 1).map(t => this.getAnswers(t)).indexOf("A");
+                        return this.mapAnswerToValue(t, [0, 1, 2, 3]) === e
+                    }
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]), s = this.aggregateAnswers();
+                    return e === s.A + s.E
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [[2, 5], [2, 4], [1, 3], [1, 4], [3, 5]]),
+                        s = this.aggregateAnswers(), n = this.getAnswers(e[0]), r = this.getAnswers(e[1]);
+                    return "C" === n && "C" === r && 2 === s.C
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    return t ? this.mapAnswerToValue(t, ["A", "C", "B", "D", "E"]) === this.getAnswers(5) : null
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    return t ? this.mapAnswerToValue(t, ["A", "C", "D", "B", "E"]) === this.getAnswers(4) : null
+                }
+            }, "simple-srq-4": class extends l {
+                constructor() {
+                    super(), f(this, "ANSWERS_LETTERS", "ABCDE".split("")), f(this, "TOTAL_ANSWERS", 5), f(this, "TOTAL_QUESTIONS", 6)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    return t ? this.mapAnswerToValue(t, ["E", "D", "C", "B", "A"]) === this.getAnswers(2) : null
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]), s = this.getAnswers(e),
+                        n = Object(i.filter)([1, 2, 3, 4, 5], t => "C" === this.getAnswers(t));
+                    return "C" === s && 1 === n.length
+                }
+
+                validateQ3() {
+                    return !!this.getAnswers(3) || null
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return this.aggregateAnswers().B === e
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.consecutives();
+                    return e[this.mapAnswerToValue(t, [0, 1, 2, 3, 4])] && 1 === e.filter(t => t).length
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return t === this.getAnswers(e)
+                }
+            }, srat: class extends l {
+                constructor() {
+                    super(), Q(this, "ANSWERS_LETTERS", "ABCDE".split("")), Q(this, "TOTAL_ANSWERS", 5), Q(this, "TOTAL_QUESTIONS", 20)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10(), this.validateQ11(), this.validateQ12(), this.validateQ13(), this.validateQ14(), this.validateQ15(), this.validateQ16(), this.validateQ17(), this.validateQ18(), this.validateQ19(), this.validateQ20()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return this.answers.indexOf("B") === e - 1
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.consecutives(), s = 1 === Object(i.filter)(e, t => t).length,
+                        n = this.mapAnswerToValue(t, [5, 6, 7, 8, 9]);
+                    return s && e[n]
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers().E;
+                    return this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === e
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers().A;
+                    return this.mapAnswerToValue(t, [4, 5, 6, 7, 8]) === e
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return t === this.getAnswers(e)
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = this.getAnswers(17);
+                    switch (t) {
+                        case"D":
+                            if ("C" !== e && "D" !== e && "E" !== e) return !0;
+                        case"E":
+                            return !1;
+                        default:
+                            return this.mapAnswerToValue(t, ["C", "D", "E", "A", "B"]) === e
+                    }
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.getAnswers(8);
+                    if (!s) return !1;
+                    const n = this.mapAnswerToValue(s, [0, 1, 2, 3, 4]), r = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]);
+                    return Math.abs(n - e) === r
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [4, 5, 6, 7, 8]), s = this.aggregateAnswers();
+                    return e === s.A + s.E
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = Object(i.range)(10, 15, 1).map(t => this.getAnswers(t)).indexOf(t);
+                    return this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === e
+                }
+
+                validateQ10() {
+                    const t = this.getAnswers(10);
+                    return t ? this.mapAnswerToValue(t, ["D", "A", "E", "B", "C"]) === this.getAnswers(16) : null
+                }
+
+                validateQ11() {
+                    const t = this.getAnswers(11);
+                    if (!t) return null;
+                    const e = Object(i.range)(1, 11, 1).map(t => this.getAnswers(t));
+                    return this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === Object(i.filter)(e, t => "B" === t).length
+                }
+
+                validateQ12() {
+                    const t = this.getAnswers(12);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = e.B + e.C + e.D;
+                    switch (t) {
+                        case"A":
+                            return -1 !== [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20].indexOf(s);
+                        case"B":
+                            return -1 !== [1, 3, 5, 7, 9, 11, 13, 15, 17, 19].indexOf(s);
+                        case"C":
+                            return -1 !== [1, 4, 9, 16].indexOf(s);
+                        case"D":
+                            return -1 !== [1, 2, 3, 5, 7, 11, 13, 17].indexOf(s);
+                        case"E":
+                            return -1 !== [5, 10, 15, 20].indexOf(s)
+                    }
+                }
+
+                validateQ13() {
+                    const t = this.getAnswers(13);
+                    if (!t) return null;
+                    this.aggregateAnswers();
+                    const e = this.mapAnswerToValue(t, [9, 11, 13, 15, 17]), s = this.getAnswers(e),
+                        n = Object(i.filter)([19, 17, 15, 13, 11, 9, 7, 5, 3, 1], t => "A" === this.getAnswers(t));
+                    return "A" === s && 1 === n.length
+                }
+
+                validateQ14() {
+                    const t = this.getAnswers(14);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers().D;
+                    return this.mapAnswerToValue(t, [6, 7, 8, 9, 10]) === e
+                }
+
+                validateQ15() {
+                    const t = this.getAnswers(15);
+                    return t ? this.mapAnswerToValue(t, ["A", "B", "C", "D", "E"]) === this.getAnswers(12) : null
+                }
+
+                validateQ16() {
+                    const t = this.getAnswers(16);
+                    return t ? this.mapAnswerToValue(t, ["D", "C", "B", "A", "E"]) === this.getAnswers(10) : null
+                }
+
+                validateQ17() {
+                    const t = this.getAnswers(17);
+                    if (!t) return null;
+                    const e = this.getAnswers(6);
+                    switch (t) {
+                        case"D":
+                            if ("C" !== e && "D" !== e && "E" !== e) return !0;
+                        case"E":
+                            return !1;
+                        default:
+                            return this.mapAnswerToValue(t, ["C", "D", "E", "A", "B"]) === e
+                    }
+                }
+
+                validateQ18() {
+                    const t = this.getAnswers(18);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, ["B", "C", "D", "E", "A"]);
+                    return "E" === t ? e.A !== e.B && e.A !== e.C && e.A !== e.D && e.A !== e.E : e.A === e[s]
+                }
+
+                validateQ19() {
+                    return !!this.getAnswers(19) || null
+                }
+
+                validateQ20() {
+                    const t = this.getAnswers(20);
+                    return t ? "E" === t : null
+                }
+            }, "dont-be-puzzled": class extends l {
+                constructor() {
+                    super(), p(this, "ANSWERS_LETTERS", "ABCDE".split("")), p(this, "TOTAL_ANSWERS", 5), p(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [4, 3, 2, 1, 1]), s = this.answers.indexOf("A");
+                    return "E" === t ? s > 3 || -1 === s : s === e - 1
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    return t ? this.consecutives()[this.mapAnswerToValue(t, [2, 3, 4, 5, 6])] : null
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = Object(i.range)(4, 9, 1).map(t => this.getAnswers(t)).indexOf("A");
+                    return this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === e
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    [2, 4, 6, 8, 10].map(t => this.getAnswers(t));
+                    const e = this.mapAnswerToValue(t, [2, 4, 6, 8, 10]);
+                    return this.answers.indexOf("B") === e - 1
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    this.aggregateAnswers();
+                    const e = this.mapAnswerToValue(t, [1, 3, 5, 7, 9]), s = this.getAnswers(e),
+                        n = Object(i.filter)([1, 3, 5, 7, 9], t => "C" === this.getAnswers(t));
+                    return "C" === s && 1 === n.length
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = Object(i.filter)([1, 2, 3, 4, 5], t => "D" === this.getAnswers(t)),
+                        s = Object(i.filter)([7, 8, 9, 10], t => "D" === this.getAnswers(t)), n = e.length >= 1,
+                        r = s.length >= 1;
+                    switch (t) {
+                        case"A":
+                            return n && !r;
+                        case"B":
+                            return !n && r;
+                        case"C":
+                            return n && r;
+                        case"D":
+                        case"E":
+                            return !1
+                    }
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = Object(i.range)(5, 10, 1).map(t => this.getAnswers(t)),
+                        s = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), n = e.lastIndexOf("E");
+                    return -1 !== n && n === s
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers();
+                    return this.mapAnswerToValue(t, [7, 6, 5, 4, 3]) === e.B + e.C + e.D
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.aggregateAnswers();
+                    return e === s.A + s.E
+                }
+
+                validateQ10() {
+                    return !!this.getAnswers(10) || null
+                }
+            }, "small-srat": class extends l {
+                constructor() {
+                    super(), T(this, "ANSWERS_LETTERS", "ABCDE".split("")), T(this, "TOTAL_ANSWERS", 5), T(this, "TOTAL_QUESTIONS", 10)
+                }
+
+                validade() {
+                    return [this.validateQ1(), this.validateQ2(), this.validateQ3(), this.validateQ4(), this.validateQ5(), this.validateQ6(), this.validateQ7(), this.validateQ8(), this.validateQ9(), this.validateQ10()]
+                }
+
+                validateQ1() {
+                    const t = this.getAnswers(1);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [2, 3, 4, 5, 6]);
+                    return this.answers.indexOf("B") === e - 1
+                }
+
+                validateQ2() {
+                    const t = this.getAnswers(2);
+                    if (!t) return null;
+                    const e = this.consecutives(), s = 1 === Object(i.filter)(e, t => t).length,
+                        n = this.mapAnswerToValue(t, [1, 2, 3, 4, 5]);
+                    return s && e[n]
+                }
+
+                validateQ3() {
+                    const t = this.getAnswers(3);
+                    if (!t) return null;
+                    const e = Object(i.range)(6, 11, 1).map(t => this.getAnswers(t)),
+                        s = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]), n = e.lastIndexOf(t);
+                    return -1 !== n && n === s
+                }
+
+                validateQ4() {
+                    const t = this.getAnswers(4);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers().A;
+                    return this.mapAnswerToValue(t, [0, 1, 2, 3, 4]) === e
+                }
+
+                validateQ5() {
+                    const t = this.getAnswers(5);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [10, 9, 8, 7, 6]);
+                    return t === this.getAnswers(e)
+                }
+
+                validateQ6() {
+                    const t = this.getAnswers(6);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = this.mapAnswerToValue(t, ["B", "C", "D", "E", "A"]);
+                    return "E" === t ? e.A !== e.B && e.A !== e.C && e.A !== e.D && e.A !== e.E : e.A === e[s]
+                }
+
+                validateQ7() {
+                    const t = this.getAnswers(7);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [0, 1, 2, 3, 4]), s = this.getAnswers(8);
+                    if (!s) return !1;
+                    const n = this.mapAnswerToValue(s, [0, 1, 2, 3, 4]), r = this.mapAnswerToValue(t, [4, 3, 2, 1, 0]);
+                    return Math.abs(n - e) === r
+                }
+
+                validateQ8() {
+                    const t = this.getAnswers(8);
+                    if (!t) return null;
+                    const e = this.mapAnswerToValue(t, [2, 3, 4, 5, 6]), s = this.aggregateAnswers();
+                    return e === s.A + s.E
+                }
+
+                validateQ9() {
+                    const t = this.getAnswers(9);
+                    if (!t) return null;
+                    const e = this.aggregateAnswers(), s = e.B + e.C + e.D;
+                    switch (t) {
+                        case"A":
+                            return -1 !== [1, 2, 3, 5, 7].indexOf(s);
+                        case"B":
+                            return -1 !== [1, 2, 6].indexOf(s);
+                        case"C":
+                            return -1 !== [1, 4, 9].indexOf(s);
+                        case"D":
+                            return -1 !== [1, 8].indexOf(s);
+                        case"E":
+                            return -1 !== [5, 10].indexOf(s)
+                    }
+                }
+
+                validateQ10() {
+                    return !!this.getAnswers(10) || null
+                }
+            }
+        };
+
+        class E {
+            constructor(t) {
+                this.won = !1, this.puzzle = t, this.$questions = r()("div[data-question]"), this.setupListeners();
+                const e = new m[this.puzzle.slug];
+                this.quiz = e, this.answers_state = Object(i.range)(e.TOTAL_QUESTIONS).map(() => Object(i.range)(e.TOTAL_ANSWERS).map(() => null))
+            }
+
+            canToggle(t, e) {
+                const {answers_state: s} = this;
+                return !0 === s[t][e] || !Object(i.some)(s[t])
+            }
+
+            toggle(t, e) {
+                if (!this.canToggle(t, e)) return;
+                const {answers_state: s} = this;
+                s[t][e] = {null: !1, true: null, false: !0}[s[t][e]]
+            }
+
+            onClick(t, e) {
+                this.toggle(t, e), this.update()
+            }
+
+            update() {
+                const t = this.getAnswers();
+                this.quiz.update(t);
+                const e = this.quiz.validade();
+                this.updateUI(e), Object(i.every)(e) && !this.won && (this.won = !0, a.a.modalEndGame(), amplitude.getInstance().logEvent("srq-win", {slug: puzzle.slug}))
+            }
+
+            updateUI(t) {
+                Object(i.forEach)(this.$questions, (e, s) => {
+                    const n = r()(e);
+                    n.removeClass("correct wrong");
+                    const i = t[s];
+                    null !== i && n.addClass(i ? "correct" : "wrong")
+                }), Object(i.forEach)(this.$questions, (t, e) => {
+                    const s = r()(t).find("ul > li"), n = Object(i.some)(this.answers_state[e]);
+                    Object(i.forEach)(s, (t, s) => {
+                        const i = r()(t);
+                        i.removeClass();
+                        const a = this.answers_state[e][s];
+                        !0 === a ? i.addClass("correct") : ((!1 === a || n) && i.addClass("wrong"), n && i.addClass("inactive"))
+                    })
+                })
+            }
+
+            setupListeners() {
+                this.$questions.on("click", "ul > li", t => {
+                    const e = r()(t.currentTarget);
+                    this.onClick(e.data("question"), e.data("alternative"))
+                })
+            }
+
+            getAnswers() {
+                return this.answers_state.map(t => {
+                    const e = t.indexOf(!0);
+                    return -1 != e ? this.quiz.ANSWERS_LETTERS[e] : null
+                })
+            }
+        }
+
+        let O = null;
+        window.loadSRQ = t => {
+            O = new E(t)
+        }
+    }, 16: function (t, e) {
+        var s;
+        s = function () {
+            return this
+        }();
+        try {
+            s = s || new Function("return this")()
+        } catch (t) {
+            "object" == typeof window && (s = window)
+        }
+        t.exports = s
+    }, 21: function (t, e, s) {
+        "use strict";
+        s.d(e, "b", (function () {
+            return i
+        })), s.d(e, "a", (function () {
+            return a
+        }));
+        var n = s(3);
+
+        function r(t, e, s) {
+            return e in t ? Object.defineProperty(t, e, {
+                value: s,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+            }) : t[e] = s, t
+        }
+
+        class i {
+            constructor(t) {
+                r(this, "$div", void 0), r(this, "$overlay", void 0), this.$div = t, this.$overlay = $('\n      <div class="overlay-endgame">\n        <div class="brand-wrapper">\n          <div class="brand"></div>\n        </div>\n      </div>')
+            }
+
+            show() {
+                return this.$div.append(this.$overlay)
+            }
+
+            hide() {
+                return this.$overlay.remove()
+            }
+        }
+
+        class a {
+            static modalBase(t, e) {
+                const s = $("#modal-".concat(t));
+                if (s.data("has-template")) {
+                    const r = s.find(".modal-body"), i = $("#templateBody-".concat(t)),
+                        a = Object(n.template)(i[0].innerHTML);
+                    r.html(a(e))
+                }
+                return s.modal("show")
+            }
+
+            static modalEndGame(t) {
+                const e = this.modalBase("end-game", t);
+                return new Promise(t => {
+                    e.on("hidden.bs.modal", () => t())
+                })
+            }
+        }
+    }, 24: function (t, e) {
+        t.exports = function (t) {
+            return t.webpackPolyfill || (t.deprecate = function () {
+            }, t.paths = [], t.children || (t.children = []), Object.defineProperty(t, "loaded", {
+                enumerable: !0,
+                get: function () {
+                    return t.l
+                }
+            }), Object.defineProperty(t, "id", {
+                enumerable: !0, get: function () {
+                    return t.i
+                }
+            }), t.webpackPolyfill = 1), t
+        }
+    }
+});
+
+console.log(1);

+ 5 - 11
test/dev/dev.ts

@@ -7,22 +7,16 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            function a (a, b) {
-               
-            }
-            
-            function b (b, c) {
-               
-            }
+            const b = function () {}
+
+            // javascript-obfuscator:disable
+            function a () {}
+            // javascript-obfuscator:enable
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
             identifierNamesGenerator: 'mangled',
-            identifiersPrefix: 'a',
-            transformObjectKeys: true,
-            stringArray: true,
-            stringArrayThreshold: 1,
             log: true
         }
     ).getObfuscatedCode();

+ 3 - 3
test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/class-declaration/ClassDeclaration.spec.ts

@@ -483,9 +483,9 @@ describe('ScopeIdentifiersTransformer ClassDeclaration identifiers', () => {
         });
 
         describe('Variant #3: preserved identifier names shouldn\'t be used as identifier names', () => {
-            const classDeclarationRegExp: RegExp = /class *f *{/;
-            const variableDeclarationsRegExp: RegExp = /let g, *h, *i, *j;/;
-            const classReferenceRegExp: RegExp = /new f\(\);/;
+            const classDeclarationRegExp: RegExp = /class *e *{/;
+            const variableDeclarationsRegExp: RegExp = /let f, *g, *h, *i;/;
+            const classReferenceRegExp: RegExp = /new e\(\);/;
 
             let obfuscatedCode: string;
 

+ 1 - 1
test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/function-declaration/FunctionDeclaration.spec.ts

@@ -146,7 +146,7 @@ describe('ScopeIdentifiersTransformer FunctionDeclaration identifiers', () => {
         describe('Variant #5: preserved identifier names shouldn\'t be used as identifier names', () => {
             describe('Variant #1', () => {
                 const functionDeclarationRegExp: RegExp = /function *e\(\) *{/;
-                const variableDeclarationsRegExp: RegExp = /let g, *h, *i, *j;/;
+                const variableDeclarationsRegExp: RegExp = /let f, *g, *h, *i;/;
 
                 let obfuscatedCode: string;
 

+ 5 - 5
test/functional-tests/node-transformers/obfuscating-transformers/scope-identifiers-transformer/variable-declaration/VariableDeclaration.spec.ts

@@ -456,11 +456,11 @@ describe('ScopeIdentifiersTransformer VariableDeclaration identifiers', () => {
 
     describe('Variant #13: preserved identifier names shouldn\'t be used as identifier names', () => {
         describe('Variant #1', () => {
-            const variableDeclarationRegExp: RegExp = /var f *= *0x1;/;
-            const functionDeclarationRegExp1: RegExp = /function *g *\(\) *{}/;
-            const functionDeclarationRegExp2: RegExp = /function *h *\(\) *{}/;
-            const functionDeclarationRegExp3: RegExp = /function *i *\(\) *{}/;
-            const functionDeclarationRegExp4: RegExp = /function *j *\(\) *{}/;
+            const variableDeclarationRegExp: RegExp = /var e *= *0x1;/;
+            const functionDeclarationRegExp1: RegExp = /function *f *\(\) *{}/;
+            const functionDeclarationRegExp2: RegExp = /function *g *\(\) *{}/;
+            const functionDeclarationRegExp3: RegExp = /function *h *\(\) *{}/;
+            const functionDeclarationRegExp4: RegExp = /function *i *\(\) *{}/;
 
             let obfuscatedCode: string;
 

+ 30 - 0
test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/VariablePreserveTransformer.spec.ts

@@ -126,4 +126,34 @@ describe('VariablePreserveTransformer', () => {
             });
         });
     });
+
+    describe('Variant #3: ignored node identifier name conflict with identifier name', () => {
+        describe('Variant #1: global scope', () => {
+            const functionExpressionIdentifierName: RegExp = /const c *= *function *\(\) *{};/;
+            const functionDeclarationIdentifierName: RegExp = /function a *\(\) *{}/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/ignored-node-identifier-name-1.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        identifierNamesGenerator: 'mangled',
+                        renameGlobals: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('should generate non-preserved name for global identifier', () => {
+                assert.match(obfuscatedCode, functionExpressionIdentifierName);
+            });
+
+            it('should keep the original name for ignored identifier', () => {
+                assert.match(obfuscatedCode, functionDeclarationIdentifierName);
+            });
+        });
+    });
 });

+ 5 - 0
test/functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/fixtures/ignored-node-identifier-name-1.js

@@ -0,0 +1,5 @@
+const b = function () {};
+
+// javascript-obfuscator:disable
+function a () {}
+// javascript-obfuscator:enable

Some files were not shown because too many files changed in this diff