@codingame/monaco-vscode-api 8.0.4 → 9.0.2

package/vscode/src/vs/editor/common/services/editorSimpleWorker.js

@@ -1,12 +1,10 @@
 import { stringDiff } from '../../../base/common/diff/diff.js';
-import { URI } from '../../../base/common/uri.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
-import { MirrorTextModel } from '../model/mirrorTextModel.js';
-import { getWordAtText, ensureValidWordDefinition } from '../core/wordHelper.js';
 import { computeLinks } from '../languages/linkComputer.js';
 import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
 import { createMonacoBaseAPI } from './editorBaseApi.js';
+import './editorWorkerHost.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
 import { DiffComputer } from '../diff/legacyLinesDiffComputer.js';
@@ -15,254 +13,43 @@ import { createProxyObject, getAllMethodNames } from '../../../base/common/objec
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
 import { findSectionHeaders } from './findSectionHeaders.js';
-class MirrorModel extends MirrorTextModel {
-    get uri() {
-        return this._uri;
-    }
-    get eol() {
-        return this._eol;
-    }
-    getValue() {
-        return this.getText();
-    }
-    findMatches(regex) {
-        const matches = [];
-        for (let i = 0; i < this._lines.length; i++) {
-            const line = this._lines[i];
-            const offsetToAdd = this.offsetAt(( new Position(i + 1, 1)));
-            const iteratorOverMatches = line.matchAll(regex);
-            for (const match of iteratorOverMatches) {
-                if (match.index || match.index === 0) {
-                    match.index = match.index + offsetToAdd;
-                }
-                matches.push(match);
-            }
-        }
-        return matches;
-    }
-    getLinesContent() {
-        return this._lines.slice(0);
-    }
-    getLineCount() {
-        return this._lines.length;
-    }
-    getLineContent(lineNumber) {
-        return this._lines[lineNumber - 1];
-    }
-    getWordAtPosition(position, wordDefinition) {
-        const wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
-        if (wordAtText) {
-            return ( new Range(
-                position.lineNumber,
-                wordAtText.startColumn,
-                position.lineNumber,
-                wordAtText.endColumn
-            ));
-        }
-        return null;
-    }
-    getWordUntilPosition(position, wordDefinition) {
-        const wordAtPosition = this.getWordAtPosition(position, wordDefinition);
-        if (!wordAtPosition) {
-            return {
-                word: '',
-                startColumn: position.column,
-                endColumn: position.column
-            };
-        }
-        return {
-            word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),
-            startColumn: wordAtPosition.startColumn,
-            endColumn: position.column
-        };
-    }
-    words(wordDefinition) {
-        const lines = this._lines;
-        const wordenize = this._wordenize.bind(this);
-        let lineNumber = 0;
-        let lineText = '';
-        let wordRangesIdx = 0;
-        let wordRanges = [];
-        return {
-            *[Symbol.iterator]() {
-                while (true) {
-                    if (wordRangesIdx < wordRanges.length) {
-                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);
-                        wordRangesIdx += 1;
-                        yield value;
-                    }
-                    else {
-                        if (lineNumber < lines.length) {
-                            lineText = lines[lineNumber];
-                            wordRanges = wordenize(lineText, wordDefinition);
-                            wordRangesIdx = 0;
-                            lineNumber += 1;
-                        }
-                        else {
-                            break;
-                        }
-                    }
-                }
-            }
-        };
-    }
-    getLineWords(lineNumber, wordDefinition) {
-        const content = this._lines[lineNumber - 1];
-        const ranges = this._wordenize(content, wordDefinition);
-        const words = [];
-        for (const range of ranges) {
-            words.push({
-                word: content.substring(range.start, range.end),
-                startColumn: range.start + 1,
-                endColumn: range.end + 1
-            });
-        }
-        return words;
-    }
-    _wordenize(content, wordDefinition) {
-        const result = [];
-        let match;
-        wordDefinition.lastIndex = 0;
-        while (match = wordDefinition.exec(content)) {
-            if (match[0].length === 0) {
-                break;
-            }
-            result.push({ start: match.index, end: match.index + match[0].length });
-        }
-        return result;
-    }
-    getValueInRange(range) {
-        range = this._validateRange(range);
-        if (range.startLineNumber === range.endLineNumber) {
-            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
-        }
-        const lineEnding = this._eol;
-        const startLineIndex = range.startLineNumber - 1;
-        const endLineIndex = range.endLineNumber - 1;
-        const resultLines = [];
-        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
-        for (let i = startLineIndex + 1; i < endLineIndex; i++) {
-            resultLines.push(this._lines[i]);
-        }
-        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
-        return resultLines.join(lineEnding);
-    }
-    offsetAt(position) {
-        position = this._validatePosition(position);
-        this._ensureLineStarts();
-        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);
-    }
-    positionAt(offset) {
-        offset = Math.floor(offset);
-        offset = Math.max(0, offset);
-        this._ensureLineStarts();
-        const out = this._lineStarts.getIndexOf(offset);
-        const lineLength = this._lines[out.index].length;
-        return {
-            lineNumber: 1 + out.index,
-            column: 1 + Math.min(out.remainder, lineLength)
-        };
-    }
-    _validateRange(range) {
-        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });
-        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });
-        if (start.lineNumber !== range.startLineNumber
-            || start.column !== range.startColumn
-            || end.lineNumber !== range.endLineNumber
-            || end.column !== range.endColumn) {
-            return {
-                startLineNumber: start.lineNumber,
-                startColumn: start.column,
-                endLineNumber: end.lineNumber,
-                endColumn: end.column
-            };
-        }
-        return range;
-    }
-    _validatePosition(position) {
-        if (!Position.isIPosition(position)) {
-            throw ( new Error('bad position'));
-        }
-        let { lineNumber, column } = position;
-        let hasChanged = false;
-        if (lineNumber < 1) {
-            lineNumber = 1;
-            column = 1;
-            hasChanged = true;
-        }
-        else if (lineNumber > this._lines.length) {
-            lineNumber = this._lines.length;
-            column = this._lines[lineNumber - 1].length + 1;
-            hasChanged = true;
-        }
-        else {
-            const maxCharacter = this._lines[lineNumber - 1].length + 1;
-            if (column < 1) {
-                column = 1;
-                hasChanged = true;
-            }
-            else if (column > maxCharacter) {
-                column = maxCharacter;
-                hasChanged = true;
-            }
-        }
-        if (!hasChanged) {
-            return position;
-        }
-        else {
-            return { lineNumber, column };
-        }
-    }
-}
-class EditorSimpleWorker {
-    constructor(host, foreignModuleFactory) {
-        this._host = host;
-        this._models = Object.create(null);
-        this._foreignModuleFactory = foreignModuleFactory;
-        this._foreignModule = null;
+import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
+class BaseEditorSimpleWorker {
+    constructor() {
+        this._workerTextModelSyncServer = ( new WorkerTextModelSyncServer());
     }
     dispose() {
-        this._models = Object.create(null);
     }
     _getModel(uri) {
-        return this._models[uri];
+        return this._workerTextModelSyncServer.getModel(uri);
     }
     _getModels() {
-        const all = [];
-        ( Object.keys(this._models)).forEach((key) => all.push(this._models[key]));
-        return all;
+        return this._workerTextModelSyncServer.getModels();
     }
-    acceptNewModel(data) {
-        this._models[data.url] = ( new MirrorModel(( URI.parse(data.url)), data.lines, data.EOL, data.versionId));
+    $acceptNewModel(data) {
+        this._workerTextModelSyncServer.$acceptNewModel(data);
     }
-    acceptModelChanged(strURL, e) {
-        if (!this._models[strURL]) {
-            return;
-        }
-        const model = this._models[strURL];
-        model.onEvents(e);
+    $acceptModelChanged(uri, e) {
+        this._workerTextModelSyncServer.$acceptModelChanged(uri, e);
     }
-    acceptRemovedModel(strURL) {
-        if (!this._models[strURL]) {
-            return;
-        }
-        delete this._models[strURL];
+    $acceptRemovedModel(uri) {
+        this._workerTextModelSyncServer.$acceptRemovedModel(uri);
     }
-    async computeUnicodeHighlights(url, options, range) {
+    async $computeUnicodeHighlights(url, options, range) {
         const model = this._getModel(url);
         if (!model) {
             return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };
         }
         return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);
     }
-    async findSectionHeaders(url, options) {
+    async $findSectionHeaders(url, options) {
         const model = this._getModel(url);
         if (!model) {
             return [];
         }
         return findSectionHeaders(model, options);
     }
-    async computeDiff(originalUrl, modifiedUrl, options, algorithm) {
+    async $computeDiff(originalUrl, modifiedUrl, options, algorithm) {
         const original = this._getModel(originalUrl);
         const modified = this._getModel(modifiedUrl);
         if (!original || !modified) {
@@ -319,7 +106,7 @@ class EditorSimpleWorker {
         }
         return true;
     }
-    async computeDirtyDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace) {
+    async $computeDirtyDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace) {
         const original = this._getModel(originalUrl);
         const modified = this._getModel(modifiedUrl);
         if (!original || !modified) {
@@ -337,7 +124,7 @@ class EditorSimpleWorker {
         return diffComputer.computeDiff().changes;
     }
     static { this._diffLimit = 100000; }
-    async computeMoreMinimalEdits(modelUrl, edits, pretty) {
+    async $computeMoreMinimalEdits(modelUrl, edits, pretty) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return edits;
@@ -399,7 +186,7 @@ class EditorSimpleWorker {
         }
         return result;
     }
-    computeHumanReadableDiff(modelUrl, edits, options) {
+    $computeHumanReadableDiff(modelUrl, edits, options) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return edits;
@@ -478,14 +265,14 @@ class EditorSimpleWorker {
         }
         return result;
     }
-    async computeLinks(modelUrl) {
+    async $computeLinks(modelUrl) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return null;
         }
         return computeLinks(model);
     }
-    async computeDefaultDocumentColors(modelUrl) {
+    async $computeDefaultDocumentColors(modelUrl) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return null;
@@ -493,7 +280,7 @@ class EditorSimpleWorker {
         return computeDefaultDocumentColors(model);
     }
     static { this._suggestionsLimit = 10000; }
-    async textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
+    async $textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {
         const sw = ( new StopWatch());
         const wordDefRegExp = ( new RegExp(wordDef, wordDefFlags));
         const seen = ( new Set());
@@ -514,7 +301,7 @@ class EditorSimpleWorker {
         }
         return { words: Array.from(seen), duration: sw.elapsed() };
     }
-    async computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
+    async $computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return Object.create(null);
@@ -542,7 +329,7 @@ class EditorSimpleWorker {
         }
         return result;
     }
-    async navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
+    async $navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {
         const model = this._getModel(modelUrl);
         if (!model) {
             return null;
@@ -565,9 +352,20 @@ class EditorSimpleWorker {
         const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
         return result;
     }
-    loadForeignModule(moduleId, createData, foreignHostMethods) {
+}
+class EditorSimpleWorker extends BaseEditorSimpleWorker {
+    constructor(_host, _foreignModuleFactory) {
+        super();
+        this._host = _host;
+        this._foreignModuleFactory = _foreignModuleFactory;
+        this._foreignModule = null;
+    }
+    async $ping() {
+        return 'pong';
+    }
+    $loadForeignModule(moduleId, createData, foreignHostMethods) {
         const proxyMethodRequest = (method, args) => {
-            return this._host.fhr(method, args);
+            return this._host.$fhr(method, args);
         };
         const foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);
         const ctx = {
@@ -582,7 +380,7 @@ class EditorSimpleWorker {
         }
         return Promise.reject(( new Error(`Unexpected usage`)));
     }
-    fmr(method, args) {
+    $fmr(method, args) {
         if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
             return Promise.reject(( new Error('Missing requestHandler or method: ' + method)));
         }
@@ -597,4 +395,4 @@ class EditorSimpleWorker {
 if (typeof importScripts === 'function') {
     globalThis.monaco = createMonacoBaseAPI();
 }
-export { EditorSimpleWorker };
+export { BaseEditorSimpleWorker, EditorSimpleWorker };

package/vscode/src/vs/editor/common/services/editorWorker.d.ts

@@ -3,7 +3,7 @@ import { URI } from '../../../base/common/uri.js';
 import { IRange } from '../core/range.js';
 import { IDocumentDiffProviderOptions, IDocumentDiff } from '../diff/documentDiffProvider.js';
 import { IChange } from '../diff/legacyLinesDiffComputer.js';
-import { TextEdit, IInplaceReplaceSupportResult } from '../languages.js';
+import { TextEdit, IInplaceReplaceSupportResult, IColorInformation } from '../languages.js';
 import { UnicodeHighlighterOptions } from './unicodeTextModelHighlighter.js';
 import { FindSectionHeaderOptions, SectionHeader } from './findSectionHeaders.js';
 
@@ -14,7 +14,7 @@ interface IEditorWorkerService {
     readonly _serviceBrand: undefined;
     canComputeUnicodeHighlights(uri: URI): boolean;
     computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult>;
-    /** Implementation in {@link EditorSimpleWorker.computeDiff} */
+    /** Implementation in {@link BaseEditorSimpleWorker.computeDiff} */
     computeDiff(original: URI, modified: URI, options: IDocumentDiffProviderOptions, algorithm: DiffAlgorithmName): Promise<IDocumentDiff | null>;
     canComputeDirtyDiff(original: URI, modified: URI): boolean;
     computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
@@ -27,6 +27,7 @@ interface IEditorWorkerService {
     canNavigateValueSet(resource: URI): boolean;
     navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<IInplaceReplaceSupportResult | null>;
     findSectionHeaders(uri: URI, options: FindSectionHeaderOptions): Promise<SectionHeader[]>;
+    computeDefaultDocumentColors(uri: URI): Promise<IColorInformation[] | null>;
 }
 interface IUnicodeHighlightsResult {
     ranges: IRange[];

package/vscode/src/vs/editor/common/services/editorWorkerBootstrap.js

@@ -0,0 +1,27 @@
+import { SimpleWorkerServer } from '../../../base/common/worker/simpleWorker.js';
+import { EditorSimpleWorker } from './editorSimpleWorker.js';
+import { EditorWorkerHost } from './editorWorkerHost.js';
+let initialized = false;
+function initialize(factory) {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    const simpleWorker = ( new SimpleWorkerServer((msg) => {
+        globalThis.postMessage(msg);
+    }, (workerServer) => ( new EditorSimpleWorker(EditorWorkerHost.getChannel(workerServer), null))));
+    globalThis.onmessage = (e) => {
+        simpleWorker.onmessage(e.data);
+    };
+}
+globalThis.onmessage = (e) => {
+    if (!initialized) {
+        initialize();
+    }
+};
+function bootstrapSimpleEditorWorker(createFn) {
+    globalThis.onmessage = () => {
+        initialize();
+    };
+}
+export { bootstrapSimpleEditorWorker, initialize };

package/vscode/src/vs/editor/common/services/editorWorkerHost.js

@@ -0,0 +1,10 @@
+class EditorWorkerHost {
+    static { this.CHANNEL_NAME = 'editorWorkerHost'; }
+    static getChannel(workerServer) {
+        return workerServer.getChannel(EditorWorkerHost.CHANNEL_NAME);
+    }
+    static setChannel(workerClient, obj) {
+        workerClient.setChannel(EditorWorkerHost.CHANNEL_NAME, obj);
+    }
+}
+export { EditorWorkerHost };

package/vscode/src/vs/editor/common/services/getIconClasses.js

@@ -84,6 +84,6 @@ function detectLanguageId(modelService, languageService, resource) {
     return languageService.guessLanguageIdByFilepathOrFirstLine(resource);
 }
 function cssEscape(str) {
-    return str.replace(/[\x11\x12\x14\x15\x40]/g, '/');
+    return str.replace(/[\s]/g, '/');
 }
 export { getIconClasses, getIconClassesForLanguageId };

package/vscode/src/vs/editor/common/services/languageService.js

@@ -1,9 +1,13 @@
-import { Emitter } from '../../../base/common/event.js';
+import { Emitter, Event } from '../../../base/common/event.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { LanguagesRegistry } from './languagesRegistry.js';
 import { firstOrDefault } from '../../../base/common/arrays.js';
 import { TokenizationRegistry } from '../languages.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
+import '../../../base/common/observableInternal/derived.js';
+import '../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../base/common/observableInternal/utils.js';
+import '../../../base/common/cancellation.js';
 class LanguageService extends Disposable {
     static { this.instanceCount = 0; }
     constructor(warnOnOverwrite = false) {
@@ -106,43 +110,12 @@ class LanguageService extends Disposable {
     }
 }
 class LanguageSelection {
-    constructor(_onDidChangeLanguages, _selector) {
-        this._onDidChangeLanguages = _onDidChangeLanguages;
-        this._selector = _selector;
-        this._listener = null;
-        this._emitter = null;
-        this.languageId = this._selector();
-    }
-    _dispose() {
-        if (this._listener) {
-            this._listener.dispose();
-            this._listener = null;
-        }
-        if (this._emitter) {
-            this._emitter.dispose();
-            this._emitter = null;
-        }
-    }
-    get onDidChange() {
-        if (!this._listener) {
-            this._listener = this._onDidChangeLanguages(() => this._evaluate());
-        }
-        if (!this._emitter) {
-            this._emitter = ( new Emitter({
-                onDidRemoveLastListener: () => {
-                    this._dispose();
-                }
-            }));
-        }
-        return this._emitter.event;
+    constructor(onDidChangeLanguages, selector) {
+        this._value = observableFromEvent(this, onDidChangeLanguages, () => selector());
+        this.onDidChange = Event.fromObservable(this._value);
     }
-    _evaluate() {
-        const languageId = this._selector();
-        if (languageId === this.languageId) {
-            return;
-        }
-        this.languageId = languageId;
-        this._emitter?.fire(this.languageId);
+    get languageId() {
+        return this._value.get();
     }
 }
 export { LanguageService };

package/vscode/src/vs/editor/common/services/modelService.js

@@ -5,10 +5,9 @@ import { OS, OperatingSystem, isLinux, isMacintosh } from '../../../base/common/
 import { EditOperation } from '../core/editOperation.js';
 import { Range } from '../core/range.js';
 import { DefaultEndOfLine, EndOfLineSequence, EndOfLinePreference } from '../model.js';
-import { createTextBuffer, TextModel } from '../model/textModel.js';
+import { TextModel, createTextBuffer } from '../model/textModel.js';
 import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../languages/modesRegistry.js';
-import { ILanguageService } from '../languages/language.js';
 import { ITextResourcePropertiesService } from './textResourceConfiguration.js';
 import { IConfigurationService } from '../../../platform/configuration/common/configuration.service.js';
 import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.service.js';
@@ -16,7 +15,7 @@ import { StringSHA1 } from '../../../base/common/hash.js';
 import { isEditStackElement } from '../model/editStack.js';
 import { Schemas } from '../../../base/common/network.js';
 import { equals } from '../../../base/common/objects.js';
-import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
 var ModelService_1;
 function MODEL_ID(resource) {
     return ( resource.toString());
@@ -49,13 +48,12 @@ class DisposedModelInfo {
 let ModelService = class ModelService extends Disposable {
     static { ModelService_1 = this; }
     static { this.MAX_MEMORY_FOR_CLOSED_FILES_UNDO_STACK = 20 * 1024 * 1024; }
-    constructor(_configurationService, _resourcePropertiesService, _undoRedoService, _languageService, _languageConfigurationService) {
+    constructor(_configurationService, _resourcePropertiesService, _undoRedoService, _instantiationService) {
         super();
         this._configurationService = _configurationService;
         this._resourcePropertiesService = _resourcePropertiesService;
         this._undoRedoService = _undoRedoService;
-        this._languageService = _languageService;
-        this._languageConfigurationService = _languageConfigurationService;
+        this._instantiationService = _instantiationService;
         this._onModelAdded = this._register(( new Emitter()));
         this.onModelAdded = this._onModelAdded.event;
         this._onModelRemoved = this._register(( new Emitter()));
@@ -237,15 +235,7 @@ let ModelService = class ModelService extends Disposable {
     }
     _createModelData(value, languageIdOrSelection, resource, isForSimpleWidget) {
         const options = this.getCreationOptions(languageIdOrSelection, resource, isForSimpleWidget);
-        const model = ( new TextModel(
-            value,
-            languageIdOrSelection,
-            options,
-            resource,
-            this._undoRedoService,
-            this._languageService,
-            this._languageConfigurationService
-        ));
+        const model = this._instantiationService.createInstance(TextModel, value, languageIdOrSelection, options, resource);
         if (resource && ( this._disposedModels.has(MODEL_ID(resource)))) {
             const disposedModelData = this._removeDisposedModel(resource);
             const elements = this._undoRedoService.getElements(resource);
@@ -476,8 +466,7 @@ ModelService = ModelService_1 = ( __decorate([
     ( __param(0, IConfigurationService)),
     ( __param(1, ITextResourcePropertiesService)),
     ( __param(2, IUndoRedoService)),
-    ( __param(3, ILanguageService)),
-    ( __param(4, ILanguageConfigurationService))
+    ( __param(3, IInstantiationService))
 ], ModelService));
 class DefaultModelSHA1Computer {
     static { this.MAX_MODEL_SIZE = 10 * 1024 * 1024; }