@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/contrib/files/browser/files.contribution.js

@@ -0,0 +1,389 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { EditorExtensions } from '../../../common/editor.js';
+import { FILES_EXCLUDE_CONFIG, FILES_ASSOCIATIONS_CONFIG, AutoSaveConfiguration, HotExitConfiguration } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { FILE_EDITOR_INPUT_ID, BINARY_TEXT_FILE_MODE } from '../common/files.js';
+import { FileEditorInput } from './editors/fileEditorInput.js';
+import { isWeb, isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { UNDO_REDO_SOURCE } from './explorerService.js';
+import { SUPPORTED_ENCODINGS } from '../../../services/textfile/common/encoding.js';
+import { editorConfigurationBaseNode } from 'monaco-editor/esm/vs/editor/common/config/editorConfigurationSchema.js';
+import { RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
+import { IExplorerService } from './files.js';
+import { ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+( Registry.as(EditorExtensions.EditorFactory)).registerFileEditorFactory({
+    typeId: FILE_EDITOR_INPUT_ID,
+    createFileEditor: (resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService) => {
+        return instantiationService.createInstance(FileEditorInput, resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents);
+    },
+    isFileEditor: (obj) => {
+        return obj instanceof FileEditorInput;
+    }
+});
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const hotExitConfiguration = isNative ?
+    {
+        'type': 'string',
+        'scope': 1 ,
+        'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
+        'default': HotExitConfiguration.ON_EXIT,
+        'markdownEnumDescriptions': [
+            ( nls.localize(
+                'hotExit.off',
+                'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
+            )),
+            ( nls.localize(
+                'hotExit.onExit',
+                'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu). All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
+            )),
+            ( nls.localize(
+                'hotExit.onExitAndWindowClose',
+                'Hot exit will be triggered when the last window is closed on Windows/Linux or when the `workbench.action.quit` command is triggered (command palette, keybinding, menu), and also for any window with a folder opened regardless of whether it\'s the last window. All windows without folders opened will be restored upon next launch. A list of previously opened windows with unsaved files can be accessed via `File > Open Recent > More...`'
+            ))
+        ],
+        'description': ( nls.localize(
+            'hotExit',
+            "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
+            HotExitConfiguration.ON_EXIT,
+            HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
+        ))
+    } : {
+    'type': 'string',
+    'scope': 1 ,
+    'enum': [HotExitConfiguration.OFF, HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE],
+    'default': HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE,
+    'markdownEnumDescriptions': [
+        ( nls.localize(
+            'hotExit.off',
+            'Disable hot exit. A prompt will show when attempting to close a window with editors that have unsaved changes.'
+        )),
+        ( nls.localize(
+            'hotExit.onExitAndWindowCloseBrowser',
+            'Hot exit will be triggered when the browser quits or the window or tab is closed.'
+        ))
+    ],
+    'description': ( nls.localize(
+        'hotExit',
+        "Controls whether unsaved files are remembered between sessions, allowing the save prompt when exiting the editor to be skipped.",
+        HotExitConfiguration.ON_EXIT,
+        HotExitConfiguration.ON_EXIT_AND_WINDOW_CLOSE
+    ))
+};
+configurationRegistry.registerConfiguration({
+    'id': 'files',
+    'order': 9,
+    'title': ( nls.localize('filesConfigurationTitle', "Files")),
+    'type': 'object',
+    'properties': {
+        [FILES_EXCLUDE_CONFIG]: {
+            'type': 'object',
+            'markdownDescription': ( nls.localize(
+                'exclude',
+                "Configure [glob patterns](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options) for excluding files and folders. For example, the File Explorer decides which files and folders to show or hide based on this setting. Refer to the `#search.exclude#` setting to define search-specific excludes. Refer to the `#explorer.excludeGitIgnore#` setting for ignoring files based on your `.gitignore`."
+            )),
+            'default': {
+                ...{ '**/.git': true, '**/.svn': true, '**/.hg': true, '**/CVS': true, '**/.DS_Store': true, '**/Thumbs.db': true },
+                ...(isWeb ? { '**/*.crswap': true  } : undefined)
+            },
+            'scope': 4 ,
+            'additionalProperties': {
+                'anyOf': [
+                    {
+                        'type': 'boolean',
+                        'enum': [true, false],
+                        'enumDescriptions': [( nls.localize('trueDescription', "Enable the pattern.")), ( nls.localize('falseDescription', "Disable the pattern."))],
+                        'description': ( nls.localize(
+                            'files.exclude.boolean',
+                            "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."
+                        )),
+                    },
+                    {
+                        'type': 'object',
+                        'properties': {
+                            'when': {
+                                'type': 'string',
+                                'pattern': '\\w*\\$\\(basename\\)\\w*',
+                                'default': '$(basename).ext',
+                                'markdownDescription': ( nls.localize(
+                                    { key: 'files.exclude.when', comment: ['\\$(basename) should not be translated'] },
+                                    "Additional check on the siblings of a matching file. Use \\$(basename) as variable for the matching file name."
+                                ))
+                            }
+                        }
+                    }
+                ]
+            }
+        },
+        [FILES_ASSOCIATIONS_CONFIG]: {
+            'type': 'object',
+            'markdownDescription': ( nls.localize(
+                'associations',
+                "Configure file associations to languages (for example `\"*.extension\": \"html\"`). These have precedence over the default associations of the languages installed."
+            )),
+            'additionalProperties': {
+                'type': 'string'
+            }
+        },
+        'files.encoding': {
+            'type': 'string',
+            'enum': ( Object.keys(SUPPORTED_ENCODINGS)),
+            'default': 'utf8',
+            'description': ( nls.localize(
+                'encoding',
+                "The default character set encoding to use when reading and writing files. This setting can also be configured per language."
+            )),
+            'scope': 5 ,
+            'enumDescriptions': ( ( Object.keys(SUPPORTED_ENCODINGS)).map(key => SUPPORTED_ENCODINGS[key].labelLong)),
+            'enumItemLabels': ( ( Object.keys(SUPPORTED_ENCODINGS)).map(key => SUPPORTED_ENCODINGS[key].labelLong))
+        },
+        'files.autoGuessEncoding': {
+            'type': 'boolean',
+            'default': false,
+            'markdownDescription': ( nls.localize(
+                'autoGuessEncoding',
+                "When enabled, the editor will attempt to guess the character set encoding when opening files. This setting can also be configured per language. Note, this setting is not respected by text search. Only {0} is respected.",
+                '`#files.encoding#`'
+            )),
+            'scope': 5
+        },
+        'files.eol': {
+            'type': 'string',
+            'enum': [
+                '\n',
+                '\r\n',
+                'auto'
+            ],
+            'enumDescriptions': [
+                ( nls.localize('eol.LF', "LF")),
+                ( nls.localize('eol.CRLF', "CRLF")),
+                ( nls.localize('eol.auto', "Uses operating system specific end of line character."))
+            ],
+            'default': 'auto',
+            'description': ( nls.localize('eol', "The default end of line character.")),
+            'scope': 5
+        },
+        'files.enableTrash': {
+            'type': 'boolean',
+            'default': true,
+            'description': ( nls.localize(
+                'useTrash',
+                "Moves files/folders to the OS trash (recycle bin on Windows) when deleting. Disabling this will delete files/folders permanently."
+            ))
+        },
+        'files.trimTrailingWhitespace': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( nls.localize(
+                'trimTrailingWhitespace',
+                "When enabled, will trim trailing whitespace when saving a file."
+            )),
+            'scope': 5
+        },
+        'files.insertFinalNewline': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( nls.localize(
+                'insertFinalNewline',
+                "When enabled, insert a final new line at the end of the file when saving it."
+            )),
+            'scope': 5
+        },
+        'files.trimFinalNewlines': {
+            'type': 'boolean',
+            'default': false,
+            'description': ( nls.localize(
+                'trimFinalNewlines',
+                "When enabled, will trim all new lines after the final new line at the end of the file when saving it."
+            )),
+            scope: 5 ,
+        },
+        'files.autoSave': {
+            'type': 'string',
+            'enum': [AutoSaveConfiguration.OFF, AutoSaveConfiguration.AFTER_DELAY, AutoSaveConfiguration.ON_FOCUS_CHANGE, AutoSaveConfiguration.ON_WINDOW_CHANGE],
+            'markdownEnumDescriptions': [
+                ( nls.localize(
+                    { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.off' },
+                    "An editor with changes is never automatically saved."
+                )),
+                ( nls.localize(
+                    { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.afterDelay' },
+                    "An editor with changes is automatically saved after the configured `#files.autoSaveDelay#`."
+                )),
+                ( nls.localize(
+                    { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onFocusChange' },
+                    "An editor with changes is automatically saved when the editor loses focus."
+                )),
+                ( nls.localize(
+                    { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'files.autoSave.onWindowChange' },
+                    "An editor with changes is automatically saved when the window loses focus."
+                ))
+            ],
+            'default': isWeb ? AutoSaveConfiguration.AFTER_DELAY : AutoSaveConfiguration.OFF,
+            'markdownDescription': ( nls.localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSave' },
+                "Controls [auto save](https://code.visualstudio.com/docs/editor/codebasics#_save-auto-save) of editors that have unsaved changes.",
+                AutoSaveConfiguration.OFF,
+                AutoSaveConfiguration.AFTER_DELAY,
+                AutoSaveConfiguration.ON_FOCUS_CHANGE,
+                AutoSaveConfiguration.ON_WINDOW_CHANGE,
+                AutoSaveConfiguration.AFTER_DELAY
+            ))
+        },
+        'files.autoSaveDelay': {
+            'type': 'number',
+            'default': 1000,
+            'minimum': 0,
+            'markdownDescription': ( nls.localize(
+                { comment: ['This is the description for a setting. Values surrounded by single quotes are not to be translated.'], key: 'autoSaveDelay' },
+                "Controls the delay in milliseconds after which an editor with unsaved changes is saved automatically. Only applies when `#files.autoSave#` is set to `{0}`.",
+                AutoSaveConfiguration.AFTER_DELAY
+            ))
+        },
+        'files.watcherExclude': {
+            'type': 'object',
+            'default': { '**/.git/objects/**': true, '**/.git/subtree-cache/**': true, '**/node_modules/*/**': true, '**/.hg/store/**': true },
+            'markdownDescription': ( nls.localize(
+                'watcherExclude',
+                "Configure paths or glob patterns to exclude from file watching. Paths can either be relative to the watched folder or absolute. Glob patterns are matched relative from the watched folder. When you experience the file watcher process consuming a lot of CPU, make sure to exclude large folders that are of less interest (such as build output folders)."
+            )),
+            'scope': 4
+        },
+        'files.watcherInclude': {
+            'type': 'array',
+            'items': {
+                'type': 'string'
+            },
+            'default': [],
+            'description': ( nls.localize(
+                'watcherInclude',
+                "Configure extra paths to watch for changes inside the workspace. By default, all workspace folders will be watched recursively, except for folders that are symbolic links. You can explicitly add absolute or relative paths to support watching folders that are symbolic links. Relative paths will be resolved to an absolute path using the currently opened workspace."
+            )),
+            'scope': 4
+        },
+        'files.hotExit': hotExitConfiguration,
+        'files.defaultLanguage': {
+            'type': 'string',
+            'markdownDescription': ( nls.localize(
+                'defaultLanguage',
+                "The default language identifier that is assigned to new files. If configured to `${activeEditorLanguage}`, will use the language identifier of the currently active text editor if any."
+            ))
+        },
+        'files.maxMemoryForLargeFilesMB': {
+            'type': 'number',
+            'default': 4096,
+            'minimum': 0,
+            'markdownDescription': ( nls.localize(
+                'maxMemoryForLargeFilesMB',
+                "Controls the memory available to VS Code after restart when trying to open large files. Same effect as specifying `--max-memory=NEWSIZE` on the command line."
+            )),
+            included: isNative
+        },
+        'files.restoreUndoStack': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'files.restoreUndoStack',
+                "Restore the undo stack when a file is reopened."
+            )),
+            'default': true
+        },
+        'files.saveConflictResolution': {
+            'type': 'string',
+            'enum': [
+                'askUser',
+                'overwriteFileOnDisk'
+            ],
+            'enumDescriptions': [
+                ( nls.localize(
+                    'askUser',
+                    "Will refuse to save and ask for resolving the save conflict manually."
+                )),
+                ( nls.localize(
+                    'overwriteFileOnDisk',
+                    "Will resolve the save conflict by overwriting the file on disk with the changes in the editor."
+                ))
+            ],
+            'description': ( nls.localize(
+                'files.saveConflictResolution',
+                "A save conflict can occur when a file is saved to disk that was changed by another program in the meantime. To prevent data loss, the user is asked to compare the changes in the editor with the version on disk. This setting should only be changed if you frequently encounter save conflict errors and may result in data loss if used without caution."
+            )),
+            'default': 'askUser',
+            'scope': 5
+        },
+        'files.simpleDialog.enable': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'files.simpleDialog.enable',
+                "Enables the simple file dialog. The simple file dialog replaces the system file dialog when enabled."
+            )),
+            'default': false
+        },
+        'files.participants.timeout': {
+            type: 'number',
+            default: 60000,
+            markdownDescription: ( nls.localize(
+                'files.participants.timeout',
+                "Timeout in milliseconds after which file participants for create, rename, and delete are cancelled. Use `0` to disable participants."
+            )),
+        }
+    }
+});
+configurationRegistry.registerConfiguration({
+    ...editorConfigurationBaseNode,
+    properties: {
+        'editor.formatOnSave': {
+            'type': 'boolean',
+            'description': ( nls.localize(
+                'formatOnSave',
+                "Format a file on save. A formatter must be available, the file must not be saved after delay, and the editor must not be shutting down."
+            )),
+            'scope': 5 ,
+        },
+        'editor.formatOnSaveMode': {
+            'type': 'string',
+            'default': 'file',
+            'enum': [
+                'file',
+                'modifications',
+                'modificationsIfAvailable'
+            ],
+            'enumDescriptions': [
+                ( nls.localize(
+                    { key: 'everything', comment: ['This is the description of an option'] },
+                    "Format the whole file."
+                )),
+                ( nls.localize(
+                    { key: 'modification', comment: ['This is the description of an option'] },
+                    "Format modifications (requires source control)."
+                )),
+                ( nls.localize(
+                    { key: 'modificationIfAvailable', comment: ['This is the description of an option'] },
+                    "Will attempt to format modifications only (requires source control). If source control can't be used, then the whole file will be formatted."
+                )),
+            ],
+            'markdownDescription': ( nls.localize(
+                'formatOnSaveMode',
+                "Controls if format on save formats the whole file or only modifications. Only applies when `#editor.formatOnSave#` is enabled."
+            )),
+            'scope': 5 ,
+        },
+    }
+});
+RedoCommand.addImplementation(110, 'explorer', (accessor) => {
+    const undoRedoService = accessor.get(IUndoRedoService);
+    const explorerService = accessor.get(IExplorerService);
+    const configurationService = accessor.get(IConfigurationService);
+    const explorerCanUndo = configurationService.getValue().explorer.enableUndo;
+    if (explorerService.hasViewFocus() && undoRedoService.canRedo(UNDO_REDO_SOURCE) && explorerCanUndo) {
+        undoRedoService.redo(UNDO_REDO_SOURCE);
+        return true;
+    }
+    return false;
+});
+ModesRegistry.registerLanguage({
+    id: BINARY_TEXT_FILE_MODE,
+    aliases: ['Binary'],
+    mimetypes: ['text/x-code-binary']
+});

package/dist/vscode/vs/workbench/contrib/files/browser/files.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IExplorerService = ( createDecorator('explorerService'));
+export { IExplorerService };

package/dist/vscode/vs/workbench/contrib/files/common/explorerFileNestingTrie.js

@@ -0,0 +1,212 @@
+class ExplorerFileNestingTrie {
+    constructor(config) {
+        this.root = ( new PreTrie());
+        for (const [parentPattern, childPatterns] of config) {
+            for (const childPattern of childPatterns) {
+                this.root.add(parentPattern, childPattern);
+            }
+        }
+    }
+    toString() {
+        return ( this.root.toString());
+    }
+    getAttributes(filename, dirname) {
+        const lastDot = filename.lastIndexOf('.');
+        if (lastDot < 1) {
+            return {
+                dirname,
+                basename: filename,
+                extname: ''
+            };
+        }
+        else {
+            return {
+                dirname,
+                basename: filename.substring(0, lastDot),
+                extname: filename.substring(lastDot + 1)
+            };
+        }
+    }
+    nest(files, dirname) {
+        const parentFinder = ( new PreTrie());
+        for (const potentialParent of files) {
+            const attributes = this.getAttributes(potentialParent, dirname);
+            const children = this.root.get(potentialParent, attributes);
+            for (const child of children) {
+                parentFinder.add(child, potentialParent);
+            }
+        }
+        const findAllRootAncestors = (file, seen = ( new Set())) => {
+            if (seen.has(file)) {
+                return [];
+            }
+            seen.add(file);
+            const attributes = this.getAttributes(file, dirname);
+            const ancestors = parentFinder.get(file, attributes);
+            if (ancestors.length === 0) {
+                return [file];
+            }
+            if (ancestors.length === 1 && ancestors[0] === file) {
+                return [file];
+            }
+            return ancestors.flatMap(a => findAllRootAncestors(a, seen));
+        };
+        const result = ( new Map());
+        for (const file of files) {
+            let ancestors = findAllRootAncestors(file);
+            if (ancestors.length === 0) {
+                ancestors = [file];
+            }
+            for (const ancestor of ancestors) {
+                let existing = result.get(ancestor);
+                if (!existing) {
+                    result.set(ancestor, existing = ( new Set()));
+                }
+                if (file !== ancestor) {
+                    existing.add(file);
+                }
+            }
+        }
+        return result;
+    }
+}
+class PreTrie {
+    constructor() {
+        this.value = ( new SufTrie());
+        this.map = ( new Map());
+    }
+    add(key, value) {
+        if (key === '') {
+            this.value.add(key, value);
+        }
+        else if (key[0] === '*') {
+            this.value.add(key, value);
+        }
+        else {
+            const head = key[0];
+            const rest = key.slice(1);
+            let existing = this.map.get(head);
+            if (!existing) {
+                this.map.set(head, existing = ( new PreTrie()));
+            }
+            existing.add(rest, value);
+        }
+    }
+    get(key, attributes) {
+        const results = [];
+        results.push(...this.value.get(key, attributes));
+        const head = key[0];
+        const rest = key.slice(1);
+        const existing = this.map.get(head);
+        if (existing) {
+            results.push(...existing.get(rest, attributes));
+        }
+        return results;
+    }
+    toString(indentation = '') {
+        const lines = [];
+        if (this.value.hasItems) {
+            lines.push('* => \n' + ( this.value.toString(indentation + '  ')));
+        }
+        return ( lines.map(l => indentation + l)).join('\n');
+    }
+}
+class SufTrie {
+    constructor() {
+        this.star = [];
+        this.epsilon = [];
+        this.map = ( new Map());
+        this.hasItems = false;
+    }
+    add(key, value) {
+        this.hasItems = true;
+        if (key === '*') {
+            this.star.push(( new SubstitutionString(value)));
+        }
+        else if (key === '') {
+            this.epsilon.push(( new SubstitutionString(value)));
+        }
+        else {
+            const tail = key[key.length - 1];
+            const rest = key.slice(0, key.length - 1);
+            if (tail === '*') {
+                throw Error('Unexpected star in SufTrie key: ' + key);
+            }
+            else {
+                let existing = this.map.get(tail);
+                if (!existing) {
+                    this.map.set(tail, existing = ( new SufTrie()));
+                }
+                existing.add(rest, value);
+            }
+        }
+    }
+    get(key, attributes) {
+        const results = [];
+        if (key === '') {
+            results.push(...( this.epsilon.map(ss => ss.substitute(attributes))));
+        }
+        if (this.star.length) {
+            results.push(...( this.star.map(ss => ss.substitute(attributes, key))));
+        }
+        const tail = key[key.length - 1];
+        const rest = key.slice(0, key.length - 1);
+        const existing = this.map.get(tail);
+        if (existing) {
+            results.push(...existing.get(rest, attributes));
+        }
+        return results;
+    }
+    toString(indentation = '') {
+        const lines = [];
+        if (this.star.length) {
+            lines.push('* => ' + this.star.join('; '));
+        }
+        if (this.epsilon.length) {
+            lines.push('ε => ' + this.epsilon.join('; '));
+        }
+        return ( lines.map(l => indentation + l)).join('\n');
+    }
+}
+const substitutionStringTokenizer = /\$[({](capture|basename|dirname|extname)[)}]/g;
+class SubstitutionString {
+    constructor(pattern) {
+        this.tokens = [];
+        substitutionStringTokenizer.lastIndex = 0;
+        let token;
+        let lastIndex = 0;
+        while (token = substitutionStringTokenizer.exec(pattern)) {
+            const prefix = pattern.slice(lastIndex, token.index);
+            this.tokens.push(prefix);
+            const type = token[1];
+            switch (type) {
+                case "basename" :
+                case "dirname" :
+                case "extname" :
+                case "capture" :
+                    this.tokens.push({ capture: type });
+                    break;
+                default: throw Error('unknown substitution type: ' + type);
+            }
+            lastIndex = token.index + token[0].length;
+        }
+        if (lastIndex !== pattern.length) {
+            const suffix = pattern.slice(lastIndex, pattern.length);
+            this.tokens.push(suffix);
+        }
+    }
+    substitute(attributes, capture) {
+        return ( this.tokens.map(t => {
+            if (typeof t === 'string') {
+                return t;
+            }
+            switch (t.capture) {
+                case "basename" : return attributes.basename;
+                case "dirname" : return attributes.dirname;
+                case "extname" : return attributes.extname;
+                case "capture" : return capture || '';
+            }
+        })).join('');
+    }
+}
+export { ExplorerFileNestingTrie, PreTrie, SufTrie };