@codingame/monaco-vscode-treesitter-service-override 14.0.6 → 15.0.1

package/assets/typescript.scm

@@ -25,20 +25,6 @@
 (regex) @string.regexp
 (number) @constant.numeric
 
-; Template TODO: These don't seem to be working
-
-(template_substitution
-  "${" @punctuation.definition.template-expression.begin
-  "}" @punctuation.definition.template-expression.end)
-
-(template_type
-  "${" @punctuation.definition.template-expression.begin
-  "}" @punctuation.definition.template-expression.end)
-
-(type_arguments
-  "<" @punctuation.bracket
-  ">" @punctuation.bracket)
-
 ; Properties
 
 (member_expression
@@ -86,6 +72,19 @@
   left: (identifier) @entity.name.function
   right: [(function_expression) (arrow_function)])
 
+(required_parameter
+  (identifier) @variable.parameter)
+
+(required_parameter
+  (rest_pattern
+    (identifier) @variable.parameter))
+
+(optional_parameter
+  (identifier) @variable.parameter)
+
+(catch_clause
+  parameter: (identifier) @variable.parameter)
+
 ; Function and method calls
 
 (call_expression
@@ -100,6 +99,8 @@
   function: (member_expression
     property: (property_identifier) @entity.name.function))
 
+(new_expression) @new.expr
+
 (new_expression
   constructor: (identifier) @entity.name.function)
 
@@ -107,8 +108,10 @@
 ; Special identifiers
 
 (predefined_type) @support.type
-(predefined_type (["string" "boolean" "number" "any"])) @support.type.primitive
+(predefined_type (["string" "boolean" "number" "any" "unknown"])) @support.type.primitive
 (type_identifier) @entity.name.type
+(internal_module
+  name: (identifier) @entity.name.type.ts)
 
 ([
   (identifier)
@@ -119,6 +122,9 @@
 (extends_clause
   value: (identifier) @entity.other.inherited-class)
 
+(implements_clause
+  (type_identifier) @entity.other.inherited-class)
+
 ; Tokens
 
 [
@@ -198,6 +204,36 @@
   "|"
 ] @keyword.operator
 
+(union_type
+  ("|") @keyword.operator.type)
+
+(intersection_type
+  ("&") @keyword.operator.type)
+
+(type_annotation
+  (":") @keyword.operator.type.annotation)
+
+[
+  "{"
+  "}"
+  "("
+  ")"
+  "["
+  "]"
+] @punctuation
+
+(template_substitution
+  "${" @punctuation.definition.template-expression.begin
+  "}" @punctuation.definition.template-expression.end)
+
+(template_type
+  "${" @punctuation.definition.template-expression.begin
+  "}" @punctuation.definition.template-expression.end)
+
+(type_arguments
+  "<" @punctuation.definition.typeparameters
+  ">" @punctuation.definition.typeparameters)
+
 ; Keywords
 
 ("typeof") @keyword.operator.expression.typeof
@@ -270,6 +306,10 @@
   "var"
 ] @storage.type
 
+[
+  "module"
+] @storage.type.namespace.ts
+
 [
   "debugger"
   "target"
@@ -289,11 +329,14 @@
 (public_field_definition
   ("?") @keyword.operator.optional)
 
-(optional_parameter)
+(property_signature
+  ("?") @keyword.operator.optional)
+
+(optional_parameter
   ([
     "?"
     ":"
-  ]) @keyword.operator.optional
+  ]) @keyword.operator.optional)
 
 (ternary_expression
   ([
@@ -306,16 +349,40 @@
 
 (rest_pattern) @keyword.operator.rest
 
-(spread_element) @keyword.operator.spread
+(spread_element
+  ("...") @keyword.operator.spread)
 
 ; Language constants
 
 [
-  (true)
-  (false)
   (null)
+] @constant.language.null
+
+[
   (undefined)
-] @constant.language
+] @constant.language.undefined
+
+ ((identifier) @constant.language.nan
+   (#eq? @constant.language.nan "NaN"))
+
+ ((identifier) @constant.language.infinity
+   (#eq? @constant.language.infinity "Infinity"))
+
+[
+  (true)
+] @constant.language.boolean.true
+
+[
+  (false)
+] @constant.language.boolean.false
+
+(literal_type
+  [
+    (null)
+    (undefined)
+    (true)
+    (false)
+  ] @support.type.builtin)
 
 (namespace_import
   "*" @constant.language)

package/index.js

@@ -1,11 +1,13 @@
 
 import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
-import { ITreeSitterParserService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService';
+import { TreeSitterImporter } from './vscode/src/vs/editor/common/services/treeSitterParserService.js';
+import { ITreeSitterParserService, ITreeSitterImporter } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/treeSitterParserService.service';
 import { TreeSitterTextModelService } from './vscode/src/vs/editor/common/services/treeSitter/treeSitterParserService.js';
 import { ITreeSitterTokenizationFeature } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.service';
 import { TreeSitterTokenizationFeature } from './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.js';
 import { registerAssets } from '@codingame/monaco-vscode-api/assets';
-import { ITreeSitterTokenizationStoreService, TreeSitterTokenizationStoreService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/treeSitterTokenStoreService';
+import { ITreeSitterTokenizationStoreService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/treeSitterTokenStoreService.service';
+import { TreeSitterTokenizationStoreService } from './vscode/src/vs/editor/common/model/treeSitterTokenStoreService.js';
 import './vscode/src/vs/workbench/services/treeSitter/browser/treeSitterTokenizationFeature.contribution.js';
 
 registerAssets({
@@ -15,6 +17,7 @@ registerAssets({
 });
 function getServiceOverride() {
     return {
+        [ITreeSitterImporter.toString()]: new SyncDescriptor(TreeSitterImporter, [], false),
         [ITreeSitterParserService.toString()]: new SyncDescriptor(TreeSitterTextModelService, [], false),
         [ITreeSitterTokenizationFeature.toString()]: new SyncDescriptor(TreeSitterTokenizationFeature, [], false),
         [ITreeSitterTokenizationStoreService.toString()]: new SyncDescriptor(TreeSitterTokenizationStoreService, [], false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-treesitter-service-override",
-  "version": "14.0.6",
+  "version": "15.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - treesitter service-override",
   "keywords": [],
@@ -15,10 +15,11 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common": "14.0.6",
-    "@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common": "14.0.6",
-    "@codingame/monaco-vscode-api": "14.0.6",
-    "@vscode/tree-sitter-wasm": "0.0.5"
+    "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common": "15.0.1",
+    "@codingame/monaco-vscode-7ba0af96-90c2-5e11-ad7f-befdbbf246c8-common": "15.0.1",
+    "@codingame/monaco-vscode-9d0168a3-519b-57f3-9bcc-89efc41f951a-common": "15.0.1",
+    "@codingame/monaco-vscode-api": "15.0.1",
+    "@vscode/tree-sitter-wasm": "0.1.3"
   },
   "main": "index.js",
   "module": "index.js",

package/vscode/src/vs/editor/common/model/tokenStore.d.ts

@@ -0,0 +1,66 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+declare class ListNode implements IDisposable {
+    readonly height: number;
+    parent?: ListNode;
+    private readonly _children;
+    get children(): ReadonlyArray<Node>;
+    private _length;
+    get length(): number;
+    constructor(height: number);
+    static create(node1: Node, node2: Node): ListNode;
+    canAppendChild(): boolean;
+    appendChild(node: Node): void;
+    private _updateParentLength;
+    unappendChild(): Node;
+    prependChild(node: Node): void;
+    unprependChild(): Node;
+    lastChild(): Node;
+    dispose(): void;
+}
+export declare enum TokenQuality {
+    None = 0,
+    ViewportGuess = 1,
+    EditGuess = 2,
+    Accurate = 3
+}
+type Node = ListNode | LeafNode;
+interface LeafNode {
+    readonly length: number;
+    parent?: ListNode;
+    token: number;
+    tokenQuality: TokenQuality;
+    height: 0;
+}
+export interface TokenUpdate {
+    readonly startOffsetInclusive: number;
+    readonly length: number;
+    readonly token: number;
+}
+export declare class TokenStore implements IDisposable {
+    private readonly _textModel;
+    private _root;
+    get root(): Node;
+    constructor(_textModel: ITextModel);
+    private createEmptyRoot;
+    buildStore(tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
+    private createFromUpdates;
+    update(length: number, tokens: TokenUpdate[], tokenQuality: TokenQuality): void;
+    delete(length: number, startOffset: number): void;
+    private replace;
+    private traverseInOrderInRange;
+    getTokenAt(offset: number): TokenUpdate | undefined;
+    getTokensInRange(startOffsetInclusive: number, endOffsetExclusive: number): TokenUpdate[];
+    markForRefresh(startOffsetInclusive: number, endOffsetExclusive: number): void;
+    rangeHasTokens(startOffsetInclusive: number, endOffsetExclusive: number, minimumTokenQuality: TokenQuality): boolean;
+    rangeNeedsRefresh(startOffsetInclusive: number, endOffsetExclusive: number): boolean;
+    getNeedsRefresh(): {
+        startOffset: number;
+        endOffset: number;
+    }[];
+    deepCopy(): TokenStore;
+    private _copyNodeIterative;
+    printTree(root?: Node): string;
+    dispose(): void;
+}
+export {};

package/vscode/src/vs/editor/common/model/tokenStore.js

@@ -0,0 +1,406 @@
+
+
+class ListNode {
+    get children() { return this._children; }
+    get length() { return this._length; }
+    constructor(height) {
+        this.height = height;
+        this._children = [];
+        this._length = 0;
+    }
+    static create(node1, node2) {
+        const list = ( new ListNode(node1.height + 1));
+        list.appendChild(node1);
+        list.appendChild(node2);
+        return list;
+    }
+    canAppendChild() {
+        return this._children.length < 3;
+    }
+    appendChild(node) {
+        if (!this.canAppendChild()) {
+            throw ( new Error('Cannot insert more than 3 children in a ListNode'));
+        }
+        this._children.push(node);
+        this._length += node.length;
+        this._updateParentLength(node.length);
+        node.parent = this;
+    }
+    _updateParentLength(delta) {
+        let updateParent = this.parent;
+        while (updateParent) {
+            updateParent._length += delta;
+            updateParent = updateParent.parent;
+        }
+    }
+    unappendChild() {
+        const child = this._children.pop();
+        this._length -= child.length;
+        this._updateParentLength(-child.length);
+        return child;
+    }
+    prependChild(node) {
+        if (this._children.length >= 3) {
+            throw ( new Error('Cannot prepend more than 3 children in a ListNode'));
+        }
+        this._children.unshift(node);
+        this._length += node.length;
+        this._updateParentLength(node.length);
+        node.parent = this;
+    }
+    unprependChild() {
+        const child = this._children.shift();
+        this._length -= child.length;
+        this._updateParentLength(-child.length);
+        return child;
+    }
+    lastChild() {
+        return this._children[this._children.length - 1];
+    }
+    dispose() {
+        this._children.splice(0, this._children.length);
+    }
+}
+var TokenQuality;
+(function (TokenQuality) {
+    TokenQuality[TokenQuality["None"] = 0] = "None";
+    TokenQuality[TokenQuality["ViewportGuess"] = 1] = "ViewportGuess";
+    TokenQuality[TokenQuality["EditGuess"] = 2] = "EditGuess";
+    TokenQuality[TokenQuality["Accurate"] = 3] = "Accurate";
+})(TokenQuality || (TokenQuality = {}));
+function isLeaf(node) {
+    return node.token !== undefined;
+}
+function append(node, nodeToAppend) {
+    let curNode = node;
+    const parents = [];
+    let nodeToAppendOfCorrectHeight;
+    while (true) {
+        if (nodeToAppend.height === curNode.height) {
+            nodeToAppendOfCorrectHeight = nodeToAppend;
+            break;
+        }
+        if (isLeaf(curNode)) {
+            throw ( new Error('unexpected'));
+        }
+        parents.push(curNode);
+        curNode = curNode.lastChild();
+    }
+    for (let i = parents.length - 1; i >= 0; i--) {
+        const parent = parents[i];
+        if (nodeToAppendOfCorrectHeight) {
+            if (parent.children.length >= 3) {
+                const newList = ListNode.create(parent.unappendChild(), nodeToAppendOfCorrectHeight);
+                nodeToAppendOfCorrectHeight = newList;
+            }
+            else {
+                parent.appendChild(nodeToAppendOfCorrectHeight);
+                nodeToAppendOfCorrectHeight = undefined;
+            }
+        }
+    }
+    if (nodeToAppendOfCorrectHeight) {
+        const newList = ( new ListNode(nodeToAppendOfCorrectHeight.height + 1));
+        newList.appendChild(node);
+        newList.appendChild(nodeToAppendOfCorrectHeight);
+        return newList;
+    }
+    else {
+        return node;
+    }
+}
+function prepend(list, nodeToAppend) {
+    let curNode = list;
+    const parents = [];
+    while (nodeToAppend.height !== curNode.height) {
+        if (isLeaf(curNode)) {
+            throw ( new Error('unexpected'));
+        }
+        parents.push(curNode);
+        curNode = curNode.children[0];
+    }
+    let nodeToPrependOfCorrectHeight = nodeToAppend;
+    for (let i = parents.length - 1; i >= 0; i--) {
+        const parent = parents[i];
+        if (nodeToPrependOfCorrectHeight) {
+            if (parent.children.length >= 3) {
+                nodeToPrependOfCorrectHeight = ListNode.create(nodeToPrependOfCorrectHeight, parent.unprependChild());
+            }
+            else {
+                parent.prependChild(nodeToPrependOfCorrectHeight);
+                nodeToPrependOfCorrectHeight = undefined;
+            }
+        }
+    }
+    if (nodeToPrependOfCorrectHeight) {
+        return ListNode.create(nodeToPrependOfCorrectHeight, list);
+    }
+    else {
+        return list;
+    }
+}
+function concat(node1, node2) {
+    if (node1.height === node2.height) {
+        return ListNode.create(node1, node2);
+    }
+    else if (node1.height > node2.height) {
+        return append(node1, node2);
+    }
+    else {
+        return prepend(node2, node1);
+    }
+}
+class TokenStore {
+    get root() {
+        return this._root;
+    }
+    constructor(_textModel) {
+        this._textModel = _textModel;
+        this._root = this.createEmptyRoot();
+    }
+    createEmptyRoot() {
+        return {
+            length: this._textModel.getValueLength(),
+            token: 0,
+            height: 0,
+            tokenQuality: TokenQuality.None
+        };
+    }
+    buildStore(tokens, tokenQuality) {
+        this._root = this.createFromUpdates(tokens, tokenQuality);
+    }
+    createFromUpdates(tokens, tokenQuality) {
+        if (tokens.length === 0) {
+            return this.createEmptyRoot();
+        }
+        let newRoot = {
+            length: tokens[0].length,
+            token: tokens[0].token,
+            height: 0,
+            tokenQuality
+        };
+        for (let j = 1; j < tokens.length; j++) {
+            newRoot = append(newRoot, { length: tokens[j].length, token: tokens[j].token, height: 0, tokenQuality });
+        }
+        return newRoot;
+    }
+    update(length, tokens, tokenQuality) {
+        if (tokens.length === 0) {
+            return;
+        }
+        this.replace(length, tokens[0].startOffsetInclusive, tokens, tokenQuality);
+    }
+    delete(length, startOffset) {
+        this.replace(length, startOffset, [], TokenQuality.EditGuess);
+    }
+    replace(length, updateOffsetStart, tokens, tokenQuality) {
+        const firstUnchangedOffsetAfterUpdate = updateOffsetStart + length;
+        const precedingNodes = [];
+        const postcedingNodes = [];
+        const stack = [{ node: this._root, offset: 0 }];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            const currentOffset = node.offset;
+            if (currentOffset < updateOffsetStart && currentOffset + node.node.length <= updateOffsetStart) {
+                node.node.parent = undefined;
+                precedingNodes.push(node.node);
+                continue;
+            }
+            else if (isLeaf(node.node) && (currentOffset < updateOffsetStart)) {
+                precedingNodes.push({ length: updateOffsetStart - currentOffset, token: node.node.token, height: 0, tokenQuality: node.node.tokenQuality });
+            }
+            if ((updateOffsetStart <= currentOffset) && (currentOffset + node.node.length <= firstUnchangedOffsetAfterUpdate)) {
+                continue;
+            }
+            if (currentOffset >= firstUnchangedOffsetAfterUpdate) {
+                node.node.parent = undefined;
+                postcedingNodes.push(node.node);
+                continue;
+            }
+            else if (isLeaf(node.node) && (currentOffset + node.node.length >= firstUnchangedOffsetAfterUpdate)) {
+                postcedingNodes.push({ length: currentOffset + node.node.length - firstUnchangedOffsetAfterUpdate, token: node.node.token, height: 0, tokenQuality: node.node.tokenQuality });
+                continue;
+            }
+            if (!isLeaf(node.node)) {
+                let childOffset = currentOffset + node.node.length;
+                for (let i = node.node.children.length - 1; i >= 0; i--) {
+                    childOffset -= node.node.children[i].length;
+                    stack.push({ node: node.node.children[i], offset: childOffset });
+                }
+            }
+        }
+        let allNodes;
+        if (tokens.length > 0) {
+            allNodes = precedingNodes.concat(this.createFromUpdates(tokens, tokenQuality), postcedingNodes);
+        }
+        else {
+            allNodes = precedingNodes.concat(postcedingNodes);
+        }
+        let newRoot = allNodes[0];
+        for (let i = 1; i < allNodes.length; i++) {
+            newRoot = concat(newRoot, allNodes[i]);
+        }
+        this._root = newRoot ?? this.createEmptyRoot();
+    }
+    traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, visitor) {
+        const stack = [{ node: this._root, offset: 0 }];
+        while (stack.length > 0) {
+            const { node, offset } = stack.pop();
+            const nodeEnd = offset + node.length;
+            if (nodeEnd <= startOffsetInclusive || offset >= endOffsetExclusive) {
+                continue;
+            }
+            if (visitor(node, offset)) {
+                return;
+            }
+            if (!isLeaf(node)) {
+                let childOffset = offset + node.length;
+                for (let i = node.children.length - 1; i >= 0; i--) {
+                    childOffset -= node.children[i].length;
+                    stack.push({ node: node.children[i], offset: childOffset });
+                }
+            }
+        }
+    }
+    getTokenAt(offset) {
+        let result;
+        this.traverseInOrderInRange(offset, this._root.length, (node, offset) => {
+            if (isLeaf(node)) {
+                result = { token: node.token, startOffsetInclusive: offset, length: node.length };
+                return true;
+            }
+            return false;
+        });
+        return result;
+    }
+    getTokensInRange(startOffsetInclusive, endOffsetExclusive) {
+        const result = [];
+        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node, offset) => {
+            if (isLeaf(node)) {
+                let clippedLength = node.length;
+                let clippedOffset = offset;
+                if ((offset < startOffsetInclusive) && (offset + node.length > endOffsetExclusive)) {
+                    clippedOffset = startOffsetInclusive;
+                    clippedLength = endOffsetExclusive - startOffsetInclusive;
+                }
+                else if (offset < startOffsetInclusive) {
+                    clippedLength -= (startOffsetInclusive - offset);
+                    clippedOffset = startOffsetInclusive;
+                }
+                else if (offset + node.length > endOffsetExclusive) {
+                    clippedLength -= (offset + node.length - endOffsetExclusive);
+                }
+                result.push({ token: node.token, startOffsetInclusive: clippedOffset, length: clippedLength });
+            }
+            return false;
+        });
+        return result;
+    }
+    markForRefresh(startOffsetInclusive, endOffsetExclusive) {
+        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
+            if (isLeaf(node)) {
+                node.tokenQuality = TokenQuality.None;
+            }
+            return false;
+        });
+    }
+    rangeHasTokens(startOffsetInclusive, endOffsetExclusive, minimumTokenQuality) {
+        let hasAny = true;
+        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
+            if (isLeaf(node) && (node.tokenQuality < minimumTokenQuality)) {
+                hasAny = false;
+            }
+            return false;
+        });
+        return hasAny;
+    }
+    rangeNeedsRefresh(startOffsetInclusive, endOffsetExclusive) {
+        let needsRefresh = false;
+        this.traverseInOrderInRange(startOffsetInclusive, endOffsetExclusive, (node) => {
+            if (isLeaf(node) && (node.tokenQuality !== TokenQuality.Accurate)) {
+                needsRefresh = true;
+            }
+            return false;
+        });
+        return needsRefresh;
+    }
+    getNeedsRefresh() {
+        const result = [];
+        this.traverseInOrderInRange(0, this._textModel.getValueLength(), (node, offset) => {
+            if (isLeaf(node) && (node.tokenQuality !== TokenQuality.Accurate)) {
+                if ((result.length > 0) && (result[result.length - 1].endOffset === offset)) {
+                    result[result.length - 1].endOffset += node.length;
+                }
+                else {
+                    result.push({ startOffset: offset, endOffset: offset + node.length });
+                }
+            }
+            return false;
+        });
+        return result;
+    }
+    deepCopy() {
+        const newStore = ( new TokenStore(this._textModel));
+        newStore._root = this._copyNodeIterative(this._root);
+        return newStore;
+    }
+    _copyNodeIterative(root) {
+        const newRoot = isLeaf(root)
+            ? { length: root.length, token: root.token, tokenQuality: root.tokenQuality, height: root.height }
+            : ( new ListNode(root.height));
+        const stack = [[root, newRoot]];
+        while (stack.length > 0) {
+            const [oldNode, clonedNode] = stack.pop();
+            if (!isLeaf(oldNode)) {
+                for (const child of oldNode.children) {
+                    const childCopy = isLeaf(child)
+                        ? { length: child.length, token: child.token, tokenQuality: child.tokenQuality, height: child.height }
+                        : ( new ListNode(child.height));
+                    clonedNode.appendChild(childCopy);
+                    stack.push([child, childCopy]);
+                }
+            }
+        }
+        return newRoot;
+    }
+    printTree(root = this._root) {
+        const result = [];
+        const stack = [[root, 0]];
+        while (stack.length > 0) {
+            const [node, depth] = stack.pop();
+            const indent = '  '.repeat(depth);
+            if (isLeaf(node)) {
+                result.push(`${indent}Leaf(length: ${node.length}, token: ${node.token}, refresh: ${node.tokenQuality})\n`);
+            }
+            else {
+                result.push(`${indent}List(length: ${node.length})\n`);
+                for (let i = node.children.length - 1; i >= 0; i--) {
+                    stack.push([node.children[i], depth + 1]);
+                }
+            }
+        }
+        return result.join('');
+    }
+    dispose() {
+        const stack = [[this._root, false]];
+        while (stack.length > 0) {
+            const [node, visited] = stack.pop();
+            if (isLeaf(node)) {
+                node.parent = undefined;
+            }
+            else if (!visited) {
+                stack.push([node, true]);
+                for (let i = node.children.length - 1; i >= 0; i--) {
+                    stack.push([node.children[i], false]);
+                }
+            }
+            else {
+                node.dispose();
+                node.parent = undefined;
+            }
+        }
+        this._root = undefined;
+    }
+}
+
+export { TokenQuality, TokenStore };