vsn 0.1.42 → 0.1.45

package/src/AST/XHRNode.ts

@@ -0,0 +1,81 @@
+import {Node} from "./Node";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {ScopeDataAbstract} from "../Scope/ScopeDataAbstract";
+
+export class XHRNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: Node | null,
+        public readonly requestType: TokenType,
+        public readonly url: Node
+    ) {
+        super();
+    }
+
+    public getChildNodes(): Node[] {
+        const nodes = [this.url];
+        if (this.left)
+            nodes.push(this.left);
+        return nodes;
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag?: Tag) {
+        const url = await this.url.evaluate(scope, dom, tag);
+        let method: string;
+        let data = this.left ? await this.left.evaluate(scope, dom, tag) : {};
+
+        if (data instanceof Scope)
+            data = data.data;
+
+        if (data instanceof ScopeDataAbstract)
+            data = data.getData();
+
+        switch (this.requestType) {
+            case TokenType.XHR_POST:
+                method = "POST";
+                break;
+            case TokenType.XHR_PUT:
+                method = "PUT";
+                break;
+            case TokenType.XHR_DELETE:
+                method = "DELETE";
+                break;
+            default:
+                method = "GET";
+        }
+
+        let request = {
+            method: method
+        };
+
+        if (request.method === 'GET') {
+
+        } else {
+            request['body'] = (typeof data === "string") ? data : JSON.stringify(data);
+        }
+
+        const response = await fetch(url, request);
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            return await response.json();
+        }
+        return await response.text();
+    }
+
+    public static parse(node: Node, token: Token, tokens: Token[]): XHRNode {
+        tokens.splice(0, 1); // Consume request type
+        const url = Tree.processTokens(Tree.getNextStatementTokens(tokens, false, false, false));
+        return new XHRNode(node, token.type, url);
+    }
+
+    public static match(tokens: Token[]) {
+        return [
+            TokenType.XHR_POST,
+            TokenType.XHR_PUT,
+            TokenType.XHR_GET,
+            TokenType.XHR_DELETE,
+        ].indexOf(tokens[0].type) > -1;
+    }
+}

package/src/AST.ts

@@ -24,6 +24,8 @@ import {ArithmeticAssignmentNode} from "./AST/ArithmeticAssignmentNode";
 import {UnitLiteralNode} from "./AST/UnitLiteralNode";
 import {BooleanLiteralNode} from "./AST/BooleanLiteralNode";
 import {NotNode} from "./AST/NotNode";
+import {XHRNode} from "./AST/XHRNode";
+import {StringFormatNode} from "./AST/StringFormatNode";
 
 function lower(str: string): string {
     return str ? str.toLowerCase() : null;
@@ -47,6 +49,7 @@ export enum BlockType {
 }
 
 export enum TokenType {
+    NULL,
     WHITESPACE,
     TYPE_INT,
     TYPE_UINT,
@@ -71,7 +74,8 @@ export enum TokenType {
     PERIOD,
     COMMA,
     COLON,
-    SEMI_COLON,
+    SEMICOLON,
+    STRING_FORMAT,
     STRING_LITERAL,
     NUMBER_LITERAL,
     BOOLEAN_LITERAL,
@@ -101,6 +105,10 @@ export enum TokenType {
     ELEMENT_STYLE,
     ELEMENT_QUERY,
     UNIT,
+    XHR_GET,
+    XHR_POST,
+    XHR_PUT,
+    XHR_DELETE,
 }
 
 const TOKEN_PATTERNS: TokenPattern[] = [
@@ -108,6 +116,22 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         type: TokenType.WHITESPACE,
         pattern: /^[\s\n\r]+/
     },
+    {
+        type: TokenType.XHR_POST,
+        pattern: /^>>/
+    },
+    {
+        type: TokenType.XHR_PUT,
+        pattern: /^<>/
+    },
+    {
+        type: TokenType.XHR_GET,
+        pattern: /^<</
+    },
+    {
+        type: TokenType.XHR_DELETE,
+        pattern: /^></
+    },
     {
         type: TokenType.TYPE_INT,
         pattern: /^int+/
@@ -257,9 +281,13 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         pattern: /^:/
     },
     {
-        type: TokenType.SEMI_COLON,
+        type: TokenType.SEMICOLON,
         pattern: /^;/
     },
+    {
+        type: TokenType.STRING_FORMAT,
+        pattern: /^`([^`]*)`/
+    },
     {
         type: TokenType.STRING_LITERAL,
         pattern: /^"([^"]*)"/
@@ -341,36 +369,38 @@ export const AttributableNodes = [
 
 export class Tree {
     protected static cache: { [key: string]: Node } = {};
-    protected rootNode: Node;
+    protected _root: Node;
 
     constructor(
         public readonly code: string
     ) {
         if (Tree.cache[code]) {
-            this.rootNode = Tree.cache[code];
+            this._root = Tree.cache[code];
         } else {
             this.parse();
-            Tree.cache[code] = this.rootNode;
+            Tree.cache[code] = this._root;
         }
     }
 
+    public get root(): Node { return this._root; }
+
     public parse() {
         const tokens = Tree.tokenize(this.code);
-        this.rootNode = Tree.processTokens(tokens);
+        this._root = Tree.processTokens(tokens);
     }
 
     async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return await this.rootNode.evaluate(scope, dom, tag);
+        return await this._root.evaluate(scope, dom, tag);
     }
 
     async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
-        if (!this.rootNode.isPreparationRequired())
+        if (!this._root.isPreparationRequired())
             return;
-        return await this.rootNode.prepare(scope, dom, tag);
+        return await this._root.prepare(scope, dom, tag);
     }
 
     async bindToScopeChanges(scope, fnc, dom: DOM, tag: Tag = null) {
-        for (const node of this.rootNode.findChildrenByTypes<ScopeMemberNode | ElementAttributeNode>([RootScopeMemberNode, ScopeMemberNode, ElementAttributeNode], 'ScopeMemberNodes')) {
+        for (const node of this._root.findChildrenByTypes<ScopeMemberNode | ElementAttributeNode>([RootScopeMemberNode, ScopeMemberNode, ElementAttributeNode], 'ScopeMemberNodes')) {
             let _scope: Scope = scope;
             if (node instanceof ScopeMemberNode)
                 _scope = await node.scope.evaluate(scope, dom);
@@ -431,14 +461,16 @@ export class Tree {
             if (count > 1000) break; // Limit to 1000 iterations while in development
 
             if (tokens[0].type === TokenType.RETURN)
-                tokens.splice(0, 1);
+                tokens.shift()
 
             const token: Token = tokens[0];
             if (token.type === TokenType.NAME) {
                 node = new RootScopeMemberNode<string>(
                     new LiteralNode<string>(token.value)
                 );
-                tokens.splice(0, 1);
+                tokens.shift()
+            } else if (XHRNode.match(tokens)) {
+                node = XHRNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.IF) {
                 node = IfStatementNode.parse(node, token, tokens);
                 blockNodes.push(node);
@@ -447,18 +479,20 @@ export class Tree {
                 node = ForStatementNode.parse(node, token, tokens);
                 blockNodes.push(node);
                 node = null;
+            } else if (StringFormatNode.match(tokens)) {
+                node = StringFormatNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.STRING_LITERAL) {
                 node = new LiteralNode(token.value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (token.type === TokenType.NUMBER_LITERAL) {
                 node = new NumberLiteralNode(token.value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_REFERENCE) {
                 node = new ElementQueryNode(tokens[0].value, true);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_QUERY) {
                 node = new ElementQueryNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.L_BRACKET) {
                 if (node) {
                     node = IndexNode.parse(node, token, tokens);
@@ -469,10 +503,10 @@ export class Tree {
                 node = ObjectNode.parse(node, token, tokens);
             } else if (tokens[0].type === TokenType.ELEMENT_ATTRIBUTE) {
                 node = new ElementAttributeNode(node as any, tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_STYLE) {
                 node = new ElementStyleNode(node as any, tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (node !== null && token.type === TokenType.PERIOD && tokens[1].type === TokenType.NAME) {
                 node = new ScopeMemberNode(
                     node,
@@ -493,12 +527,12 @@ export class Tree {
                 } else {
                     node = new BlockNode(nodes);
                 }
-            } else if (tokens[0].type === TokenType.SEMI_COLON) {
+            } else if (tokens[0].type === TokenType.SEMICOLON) {
                 if (node) {
                     blockNodes.push(node);
                 }
                 node = null;
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (InNode.match(tokens)) {
                 node = InNode.parse(node, token, tokens);
             } else if (ComparisonNode.match(tokens)) {
@@ -508,16 +542,16 @@ export class Tree {
             } else if (ArithmeticAssignmentNode.match(tokens)) {
                 node = ArithmeticAssignmentNode.parse(node, token, tokens);
             } else if (tokens[0].type === TokenType.WHITESPACE) {
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.UNIT) {
                 node = new UnitLiteralNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.BOOLEAN_LITERAL) {
                 node = new BooleanLiteralNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.NULL_LITERAL) {
                 node = new LiteralNode(null);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.EXCLAMATION_POINT) {
                 node = NotNode.parse(node, tokens[0], tokens);
             } else {
@@ -583,7 +617,7 @@ export class Tree {
                 break;
             default:
                 open = null;
-                close = TokenType.SEMI_COLON;
+                close = TokenType.SEMICOLON;
                 openCharacter = null;
                 closeCharacter = ';';
                 break;
@@ -603,7 +637,7 @@ export class Tree {
 
         // Consume opening block token
         if (consumeOpeningToken && tokens[0].type === blockInfo.open) {
-            tokens.splice(0, 1);
+            tokens.shift()
         }
 
         return Tree.getTokensUntil(tokens, blockInfo.close, consumeClosingToken, includeClosingToken);
@@ -632,7 +666,7 @@ export class Tree {
             }
 
             // Consume token
-            tokens.splice(0, 1);
+            tokens.shift()
             i--;
             if (openBlocks === 0) {
                 if (arg.length > 0)
@@ -644,7 +678,7 @@ export class Tree {
         throw Error(`Invalid Syntax, missing ${blockInfo.closeCharacter}`);
     }
 
-    public static getTokensUntil(tokens: Token[], terminator: TokenType = TokenType.SEMI_COLON, consumeTerminator: boolean = true, includeTerminator: boolean = false, validIfTerminatorNotFound: boolean = false, blockInfo: IBlockInfo = null): Token[] {
+    public static getTokensUntil(tokens: Token[], terminator: TokenType = TokenType.SEMICOLON, consumeTerminator: boolean = true, includeTerminator: boolean = false, validIfTerminatorNotFound: boolean = false, blockInfo: IBlockInfo = null): Token[] {
         const statementTokens: Token[] = [];
         blockInfo = blockInfo || Tree.getBlockInfo(tokens);
 
@@ -681,8 +715,9 @@ export class Tree {
                     if (includeTerminator)
                         statementTokens.push(token);
 
-                    if ((includeTerminator || consumeTerminator) && token.type !== TokenType.SEMI_COLON)
-                        tokens.splice(0, 1); // Consume end of block
+                    //if (consumeTerminator && token.type !== TokenType.SEMICOLON)
+                    if ((includeTerminator || consumeTerminator) && token.type !== TokenType.SEMICOLON)
+                        tokens.shift() // Consume end of block
                     break;
                 } else if (token.type === terminator && (openParens > 0 || openBraces > 0 || openBrackets > 0)) {
                 } else {
@@ -693,7 +728,7 @@ export class Tree {
             }
 
             statementTokens.push(token);
-            tokens.splice(0, 1); // Consume part of statement
+            tokens.shift() // Consume part of statement
             i--;
         }
         return statementTokens;

package/src/DOM.ts

@@ -3,8 +3,6 @@ import {ElementHelper} from "./helpers/ElementHelper";
 import {Configuration} from "./Configuration";
 import {Tree} from "./AST";
 import {TagList} from "./Tag/List";
-import {benchmarkEnd, benchmarkStart} from "./Bencmark";
-import {VisionHelper} from "./helpers/VisionHelper";
 import {WrappedWindow} from "./DOM/WrappedWindow";
 import {WrappedDocument} from "./DOM/WrappedDocument";
 import {Scope} from "./Scope";
@@ -50,6 +48,8 @@ export class DOM extends EventDispatcher {
                 return new TagList(this.window);
             case 'document':
                 return new TagList(this.document);
+            case 'body':
+                return new TagList(this.root);
             default:
                 const nodes = this.querySelectorAll(selector, tag);
                 return await this.getTagsForElements(Array.from(nodes) as Element[], create);
@@ -139,7 +139,6 @@ export class DOM extends EventDispatcher {
         const toBuild: HTMLElement[] = [];
         const toSkip: HTMLElement[] = [];
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','findElements');
         if (ele && ele.querySelectorAll) {
             for (const element of (Array.from(ele.querySelectorAll(`*`)) as HTMLElement[])) { // Don't build items more than once
                 if (!ElementHelper.hasVisionAttribute(element)) continue;
@@ -152,9 +151,7 @@ export class DOM extends EventDispatcher {
                 toBuild.push(element);
             }
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'findElements');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTags');
         for (const element of toBuild) {
             if (allElements.indexOf(element) > -1) continue;
             const tag: Tag = new Tag(element, this);
@@ -162,23 +159,17 @@ export class DOM extends EventDispatcher {
             newTags.push(tag);
             allElements.push(element as HTMLElement);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTags');
 
         if (isRoot)
             this._root = await this.getTagForElement(document.body);
 
         // Configure, setup & execute attributes
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','buildTagAttributes');
         for (const tag of newTags)
             await tag.buildAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','buildTagAttributes');
 
-        if (VisionHelper.inDevelopment) benchmarkStart('DOM', 'compileAttributes');
         for (const tag of newTags)
             await tag.compileAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','compileAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTree');
         for (const tag of newTags) {
             if (tag === this.root)
                 continue;
@@ -198,39 +189,27 @@ export class DOM extends EventDispatcher {
             if (!foundParent)
                 console.error('Could not find parent for ', tag);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTree');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'setupAttributes');
         for (const tag of newTags)
             await tag.setupAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'setupAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'extractAttributes');
         for (const tag of newTags)
             await tag.extractAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'extractAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'connectAttributes');
         for (const tag of newTags)
             await tag.connectAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'connectAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'finalizeTags');
         for (const tag of newTags) {
             await tag.finalize();
             this.queued.splice(this.queued.indexOf(tag.element), 1);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'finalizeTags');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'observeTags');
-        for (const tag of newTags)
-            this.observer.observe(tag.element, {
+        newTags.forEach(tag => this.observer.observe(tag.element, {
                 attributes: true,
                 characterData: true,
                 childList: true,
                 subtree: true
-            });
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'observeTags');
+            }));
 
         this.dispatch('built');
     }

package/src/Registry.ts

@@ -1,4 +1,3 @@
-import {VisionHelper} from "./helpers/VisionHelper";
 import {EventDispatcher} from "./EventDispatcher";
 import {IDeferred, IPromise, SimplePromise} from "./SimplePromise";
 
@@ -53,6 +52,7 @@ export class RegistryStore extends EventDispatcher {
 
 export class Registry extends EventDispatcher {
     protected static _instance: Registry;
+    public readonly components: RegistryStore;
     public readonly classes: RegistryStore;
     public readonly models: RegistryStore;
     public readonly templates: RegistryStore;
@@ -63,15 +63,18 @@ export class Registry extends EventDispatcher {
 
     constructor() {
         super();
+        this.components = new RegistryStore();
+        this.classes = new RegistryStore();
+        this.models = new RegistryStore();
+        this.templates = new RegistryStore();
+        this.types = new RegistryStore();
+        this.validators = new RegistryStore();
+        this.formats = new RegistryStore();
+        this.attributes = new RegistryStore();
+    }
 
-        const w = VisionHelper.window || {};
-        this.classes = new RegistryStore(w['$classes'] || {});
-        this.models = new RegistryStore(w['$models'] || {});
-        this.templates = new RegistryStore(w['$templates'] || {});
-        this.types = new RegistryStore(w['$types'] || {});
-        this.validators = new RegistryStore(w['$validators'] || {});
-        this.formats = new RegistryStore(w['$formats'] || {});
-        this.attributes = new RegistryStore(w['$attributes'] || {});
+    public static component(key: string = null, setup = null) {
+        return register('components', key, setup);
     }
 
     public static class(key: string = null, setup = null) {

package/src/Scope/ScopeDataAbstract.ts

@@ -65,7 +65,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         const keys = [];
         for (const key of this.keys) {
             const property = this.getProperty(key);
-            if (property.hasTags(tags)) {
+            if (property.hasLabels(tags)) {
                 keys.push(key);
             }
         }
@@ -86,7 +86,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         propLoop: for (const key of this.getProperties()) {
             const property = this['__'+key];
             for (const tag of tags) {
-                if (!property.hasTag(tag))
+                if (!property.hasLabel(tag))
                     continue propLoop;
             }
 

package/src/Scope/properties/Property.ts

@@ -30,7 +30,7 @@ export interface IPropertyConfig {
     type?: string;
     default?: any;
     validators?: TValidator[];
-    tags?: string[];
+    labels?: string[];
 }
 
 export class Property<T = any> extends EventDispatcher {
@@ -41,8 +41,8 @@ export class Property<T = any> extends EventDispatcher {
     constructor(value?: T, config?: IPropertyConfig) {
         super();
         this.config = config;
-        if (!this.config.tags)
-            this.config.tags = [];
+        if (!this.config.labels)
+            this.config.labels = [];
         if (!this.config.validators)
             this.config.validators = [];
         this.type = config.type || 'any';
@@ -93,55 +93,48 @@ export class Property<T = any> extends EventDispatcher {
         return errors;
     }
 
-    addValidator(validator: TValidator | string) {
-        if (typeof validator == 'string')
-            validator = Registry.instance.validators.getSynchronous(validator) as TValidator;
-
+    getValidator(id: string) {
+        const validator = Registry.instance.validators.getSynchronous(id) as TValidator;
         if (!validator)
-            throw new Error('Invalid validator');
-
-        if (this.config.validators.indexOf(validator) == -1)
-            this.config.validators.push(validator);
+            throw new Error(`Invalid validator ${id}`);
+        return validator;
     }
 
-    removeValidator(validator: TValidator | string) {
-        if (typeof validator == 'string')
-            validator = Registry.instance.validators.getSynchronous(validator) as TValidator;
-
-        if (!validator)
-            throw new Error('Invalid validator');
+    addValidator(validator: TValidator | string) {
+        if (typeof validator == 'string') {
+            validator = this.getValidator(validator);
+        }
 
-        const index = this.config.validators.indexOf(validator);
-        if (index != -1)
-            this.config.validators.splice(index, 1);
+        if (this.config.validators.indexOf(validator) == -1)
+            this.config.validators.push(validator);
     }
 
-    addTag(tag: string) {
-        if(this.config.tags == undefined) {
-            this.config.tags = [];
+    addLabel(label: string) {
+        if(this.config.labels == undefined) {
+            this.config.labels = [];
         }
-        if(this.config.tags.indexOf(tag) == -1) {
-            this.config.tags.push(tag);
+        if(this.config.labels.indexOf(label) == -1) {
+            this.config.labels.push(label);
         }
     }
 
-    removeTag(tag: string) {
-        if(this.config.tags == undefined) {
+    removeLabel(label: string) {
+        if(this.config.labels == undefined) {
             return;
         }
-        const index = this.config.tags.indexOf(tag);
+        const index = this.config.labels.indexOf(label);
         if(index != -1) {
-            this.config.tags.splice(index, 1);
+            this.config.labels.splice(index, 1);
         }
     }
 
-    hasTag(tag: string) {
-        return this.config.tags.indexOf(tag) !== -1;
+    hasLabel(label: string) {
+        return this.config.labels.indexOf(label) !== -1;
     }
 
-    hasTags(tags: string[]) {
-        for(const tag of tags) {
-            if(!this.hasTag(tag)) {
+    hasLabels(labels: string[]) {
+        for(const label of labels) {
+            if(!this.hasLabel(label)) {
                 return false;
             }
         }

package/src/Scope/properties/_imports.ts

@@ -1,2 +1,2 @@
-export {Property, property} from './Property';
+export {Property, property, IPropertyConfig} from './Property';
 export {ArrayProperty} from './ArrayProperty';

package/src/Tag.ts

@@ -72,12 +72,7 @@ export class Tag extends DOMObject {
         if (this._nonDeferredAttributes.length > 0)
             return this._nonDeferredAttributes;
 
-        const attrs: Attribute[] = [];
-        for (const attribute of this.attributes) {
-            if (attribute.state === AttributeState.Deferred)
-                continue;
-            attrs.push(attribute);
-        }
+        const attrs: Attribute[] = this.attributes.filter(attr => attr.state !== AttributeState.Deferred);
         this._nonDeferredAttributes = attrs;
         return attrs;
     }
@@ -119,9 +114,7 @@ export class Tag extends DOMObject {
     }
 
     mutate(mutation: MutationRecord): void {
-        for (const attr of this.attributes) {
-            attr.mutate(mutation);
-        }
+        this.attributes.map(attr => attr.mutate(mutation));
         this.dispatch('mutate', mutation);
     }
 

package/src/attributes/AddClassIf.ts

@@ -11,4 +11,4 @@ export class AddClassIf extends If {
             this.tag.element.classList.remove(this.getAttributeBinding());
         }
     }
-}
+}

package/src/attributes/_imports.ts

@@ -1,7 +1,5 @@
 export {AddClassIf} from "./AddClassIf";
 export {Bind} from "./Bind";
-export {ClickRemoveClass} from "./ClickRemoveClass";
-export {ClickToggleClass} from "./ClickToggleClass";
 export {ControllerAttribute} from "./ControllerAttribute";
 export {DisableIf} from "./DisableIf";
 export {Exec} from "./Exec";

package/src/helpers/VisionHelper.ts

@@ -47,4 +47,17 @@ export class VisionHelper {
             setTimeout(callback, timeout);
         }
     }
+
+    public static get wasmSupport(): boolean {
+        try {
+            if (typeof WebAssembly === "object"
+                && typeof WebAssembly.instantiate === "function") {
+                const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
+                if (module instanceof WebAssembly.Module)
+                    return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+            }
+        } catch (e) {
+        }
+        return false;
+    }
 }