{"version":3,"file":"monaco-editor.worker.js","mappings":"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","sources":["webpack:///webpack/bootstrap","webpack:///webpack/runtime/global","webpack:///../node_modules/monaco-editor/esm/vs/base/common/errors.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/functional.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/iterator.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/lifecycle.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/platform.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/linkedList.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/stopwatch.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/event.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/types.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/strings.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/worker/simpleWorker.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/process.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/diff/diffChange.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/hash.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/diff/diff.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/path.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/uri.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/core/position.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/core/range.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/diff/diffComputer.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/uint.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/viewModel/prefixSumComputer.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/model/wordHelper.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/modes/linkComputer.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/modes/supports/inplaceReplaceSupport.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/cancellation.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/keyCodes.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneEnums.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/core/selection.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/core/token.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/standalone/standaloneBase.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/controller/wordCharacterClassifier.js","webpack:///../node_modules/monaco-editor/esm/vs/base/common/objects.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/model.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/model/textModelSearch.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/modes/unicodeTextModelHighlighter.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js","webpack:///../node_modules/monaco-editor/esm/vs/editor/editor.worker.js"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","// Avoid circular dependency on EventEmitter by implementing a subset of the interface.\nexport class ErrorHandler {\n    constructor() {\n        this.listeners = [];\n        this.unexpectedErrorHandler = function (e) {\n            setTimeout(() => {\n                if (e.stack) {\n                    throw new Error(e.message + '\\n\\n' + e.stack);\n                }\n                throw e;\n            }, 0);\n        };\n    }\n    emit(e) {\n        this.listeners.forEach((listener) => {\n            listener(e);\n        });\n    }\n    onUnexpectedError(e) {\n        this.unexpectedErrorHandler(e);\n        this.emit(e);\n    }\n    // For external errors, we don't want the listeners to be called\n    onUnexpectedExternalError(e) {\n        this.unexpectedErrorHandler(e);\n    }\n}\nexport const errorHandler = new ErrorHandler();\nexport function onUnexpectedError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedError(e);\n    }\n    return undefined;\n}\nexport function onUnexpectedExternalError(e) {\n    // ignore errors from cancelled promises\n    if (!isPromiseCanceledError(e)) {\n        errorHandler.onUnexpectedExternalError(e);\n    }\n    return undefined;\n}\nexport function transformErrorForSerialization(error) {\n    if (error instanceof Error) {\n        let { name, message } = error;\n        const stack = error.stacktrace || error.stack;\n        return {\n            $isError: true,\n            name,\n            message,\n            stack\n        };\n    }\n    // return as is\n    return error;\n}\nconst canceledName = 'Canceled';\n/**\n * Checks if the given error is a promise in canceled state\n */\nexport function isPromiseCanceledError(error) {\n    return error instanceof Error && error.name === canceledName && error.message === canceledName;\n}\n/**\n * Returns an error that signals cancellation.\n */\nexport function canceled() {\n    const error = new Error(canceledName);\n    error.name = error.message;\n    return error;\n}\nexport function illegalArgument(name) {\n    if (name) {\n        return new Error(`Illegal argument: ${name}`);\n    }\n    else {\n        return new Error('Illegal argument');\n    }\n}\nexport function illegalState(name) {\n    if (name) {\n        return new Error(`Illegal state: ${name}`);\n    }\n    else {\n        return new Error('Illegal state');\n    }\n}\nexport class NotSupportedError extends Error {\n    constructor(message) {\n        super('NotSupported');\n        if (message) {\n            this.message = message;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function once(fn) {\n    const _this = this;\n    let didCall = false;\n    let result;\n    return function () {\n        if (didCall) {\n            return result;\n        }\n        didCall = true;\n        result = fn.apply(_this, arguments);\n        return result;\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport var Iterable;\n(function (Iterable) {\n    function is(thing) {\n        return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';\n    }\n    Iterable.is = is;\n    const _empty = Object.freeze([]);\n    function empty() {\n        return _empty;\n    }\n    Iterable.empty = empty;\n    function* single(element) {\n        yield element;\n    }\n    Iterable.single = single;\n    function from(iterable) {\n        return iterable || _empty;\n    }\n    Iterable.from = from;\n    function isEmpty(iterable) {\n        return !iterable || iterable[Symbol.iterator]().next().done === true;\n    }\n    Iterable.isEmpty = isEmpty;\n    function first(iterable) {\n        return iterable[Symbol.iterator]().next().value;\n    }\n    Iterable.first = first;\n    function some(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    Iterable.some = some;\n    function find(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                return element;\n            }\n        }\n        return undefined;\n    }\n    Iterable.find = find;\n    function* filter(iterable, predicate) {\n        for (const element of iterable) {\n            if (predicate(element)) {\n                yield element;\n            }\n        }\n    }\n    Iterable.filter = filter;\n    function* map(iterable, fn) {\n        let index = 0;\n        for (const element of iterable) {\n            yield fn(element, index++);\n        }\n    }\n    Iterable.map = map;\n    function* concat(...iterables) {\n        for (const iterable of iterables) {\n            for (const element of iterable) {\n                yield element;\n            }\n        }\n    }\n    Iterable.concat = concat;\n    function* concatNested(iterables) {\n        for (const iterable of iterables) {\n            for (const element of iterable) {\n                yield element;\n            }\n        }\n    }\n    Iterable.concatNested = concatNested;\n    function reduce(iterable, reducer, initialValue) {\n        let value = initialValue;\n        for (const element of iterable) {\n            value = reducer(value, element);\n        }\n        return value;\n    }\n    Iterable.reduce = reduce;\n    /**\n     * Returns an iterable slice of the array, with the same semantics as `array.slice()`.\n     */\n    function* slice(arr, from, to = arr.length) {\n        if (from < 0) {\n            from += arr.length;\n        }\n        if (to < 0) {\n            to += arr.length;\n        }\n        else if (to > arr.length) {\n            to = arr.length;\n        }\n        for (; from < to; from++) {\n            yield arr[from];\n        }\n    }\n    Iterable.slice = slice;\n    /**\n     * Consumes `atMost` elements from iterable and returns the consumed elements,\n     * and an iterable for the rest of the elements.\n     */\n    function consume(iterable, atMost = Number.POSITIVE_INFINITY) {\n        const consumed = [];\n        if (atMost === 0) {\n            return [consumed, iterable];\n        }\n        const iterator = iterable[Symbol.iterator]();\n        for (let i = 0; i < atMost; i++) {\n            const next = iterator.next();\n            if (next.done) {\n                return [consumed, Iterable.empty()];\n            }\n            consumed.push(next.value);\n        }\n        return [consumed, { [Symbol.iterator]() { return iterator; } }];\n    }\n    Iterable.consume = consume;\n    /**\n     * Returns whether the iterables are the same length and all items are\n     * equal using the comparator function.\n     */\n    function equals(a, b, comparator = (at, bt) => at === bt) {\n        const ai = a[Symbol.iterator]();\n        const bi = b[Symbol.iterator]();\n        while (true) {\n            const an = ai.next();\n            const bn = bi.next();\n            if (an.done !== bn.done) {\n                return false;\n            }\n            else if (an.done) {\n                return true;\n            }\n            else if (!comparator(an.value, bn.value)) {\n                return false;\n            }\n        }\n    }\n    Iterable.equals = equals;\n})(Iterable || (Iterable = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { once } from './functional.js';\nimport { Iterable } from './iterator.js';\n/**\n * Enables logging of potentially leaked disposables.\n *\n * A disposable is considered leaked if it is not disposed or not registered as the child of\n * another disposable. This tracking is very simple an only works for classes that either\n * extend Disposable or use a DisposableStore. This means there are a lot of false positives.\n */\nconst TRACK_DISPOSABLES = false;\nlet disposableTracker = null;\nexport function setDisposableTracker(tracker) {\n    disposableTracker = tracker;\n}\nif (TRACK_DISPOSABLES) {\n    const __is_disposable_tracked__ = '__is_disposable_tracked__';\n    setDisposableTracker(new class {\n        trackDisposable(x) {\n            const stack = new Error('Potentially leaked disposable').stack;\n            setTimeout(() => {\n                if (!x[__is_disposable_tracked__]) {\n                    console.log(stack);\n                }\n            }, 3000);\n        }\n        setParent(child, parent) {\n            if (child && child !== Disposable.None) {\n                try {\n                    child[__is_disposable_tracked__] = true;\n                }\n                catch (_a) {\n                    // noop\n                }\n            }\n        }\n        markAsDisposed(disposable) {\n            if (disposable && disposable !== Disposable.None) {\n                try {\n                    disposable[__is_disposable_tracked__] = true;\n                }\n                catch (_a) {\n                    // noop\n                }\n            }\n        }\n        markAsSingleton(disposable) { }\n    });\n}\nfunction trackDisposable(x) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.trackDisposable(x);\n    return x;\n}\nfunction markAsDisposed(disposable) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsDisposed(disposable);\n}\nfunction setParentOfDisposable(child, parent) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.setParent(child, parent);\n}\nfunction setParentOfDisposables(children, parent) {\n    if (!disposableTracker) {\n        return;\n    }\n    for (const child of children) {\n        disposableTracker.setParent(child, parent);\n    }\n}\n/**\n * Indicates that the given object is a singleton which does not need to be disposed.\n*/\nexport function markAsSingleton(singleton) {\n    disposableTracker === null || disposableTracker === void 0 ? void 0 : disposableTracker.markAsSingleton(singleton);\n    return singleton;\n}\nexport class MultiDisposeError extends Error {\n    constructor(errors) {\n        super(`Encountered errors while disposing of store. Errors: [${errors.join(', ')}]`);\n        this.errors = errors;\n    }\n}\nexport function isDisposable(thing) {\n    return typeof thing.dispose === 'function' && thing.dispose.length === 0;\n}\nexport function dispose(arg) {\n    if (Iterable.is(arg)) {\n        let errors = [];\n        for (const d of arg) {\n            if (d) {\n                try {\n                    d.dispose();\n                }\n                catch (e) {\n                    errors.push(e);\n                }\n            }\n        }\n        if (errors.length === 1) {\n            throw errors[0];\n        }\n        else if (errors.length > 1) {\n            throw new MultiDisposeError(errors);\n        }\n        return Array.isArray(arg) ? [] : arg;\n    }\n    else if (arg) {\n        arg.dispose();\n        return arg;\n    }\n}\nexport function combinedDisposable(...disposables) {\n    const parent = toDisposable(() => dispose(disposables));\n    setParentOfDisposables(disposables, parent);\n    return parent;\n}\nexport function toDisposable(fn) {\n    const self = trackDisposable({\n        dispose: once(() => {\n            markAsDisposed(self);\n            fn();\n        })\n    });\n    return self;\n}\nexport class DisposableStore {\n    constructor() {\n        this._toDispose = new Set();\n        this._isDisposed = false;\n        trackDisposable(this);\n    }\n    /**\n     * Dispose of all registered disposables and mark this object as disposed.\n     *\n     * Any future disposables added to this object will be disposed of on `add`.\n     */\n    dispose() {\n        if (this._isDisposed) {\n            return;\n        }\n        markAsDisposed(this);\n        this._isDisposed = true;\n        this.clear();\n    }\n    /**\n     * Dispose of all registered disposables but do not mark this object as disposed.\n     */\n    clear() {\n        try {\n            dispose(this._toDispose.values());\n        }\n        finally {\n            this._toDispose.clear();\n        }\n    }\n    add(o) {\n        if (!o) {\n            return o;\n        }\n        if (o === this) {\n            throw new Error('Cannot register a disposable on itself!');\n        }\n        setParentOfDisposable(o, this);\n        if (this._isDisposed) {\n            if (!DisposableStore.DISABLE_DISPOSED_WARNING) {\n                console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);\n            }\n        }\n        else {\n            this._toDispose.add(o);\n        }\n        return o;\n    }\n}\nDisposableStore.DISABLE_DISPOSED_WARNING = false;\nexport class Disposable {\n    constructor() {\n        this._store = new DisposableStore();\n        trackDisposable(this);\n        setParentOfDisposable(this._store, this);\n    }\n    dispose() {\n        markAsDisposed(this);\n        this._store.dispose();\n    }\n    _register(o) {\n        if (o === this) {\n            throw new Error('Cannot register a disposable on itself!');\n        }\n        return this._store.add(o);\n    }\n}\nDisposable.None = Object.freeze({ dispose() { } });\n/**\n * Manages the lifecycle of a disposable value that may be changed.\n *\n * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can\n * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.\n */\nexport class MutableDisposable {\n    constructor() {\n        this._isDisposed = false;\n        trackDisposable(this);\n    }\n    get value() {\n        return this._isDisposed ? undefined : this._value;\n    }\n    set value(value) {\n        var _a;\n        if (this._isDisposed || value === this._value) {\n            return;\n        }\n        (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n        if (value) {\n            setParentOfDisposable(value, this);\n        }\n        this._value = value;\n    }\n    clear() {\n        this.value = undefined;\n    }\n    dispose() {\n        var _a;\n        this._isDisposed = true;\n        markAsDisposed(this);\n        (_a = this._value) === null || _a === void 0 ? void 0 : _a.dispose();\n        this._value = undefined;\n    }\n    /**\n     * Clears the value, but does not dispose it.\n     * The old value is returned.\n    */\n    clearAndLeak() {\n        const oldValue = this._value;\n        this._value = undefined;\n        if (oldValue) {\n            setParentOfDisposable(oldValue, null);\n        }\n        return oldValue;\n    }\n}\nexport class ImmortalReference {\n    constructor(object) {\n        this.object = object;\n    }\n    dispose() { }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar _a;\nconst LANGUAGE_DEFAULT = 'en';\nlet _isWindows = false;\nlet _isMacintosh = false;\nlet _isLinux = false;\nlet _isLinuxSnap = false;\nlet _isNative = false;\nlet _isWeb = false;\nlet _isElectron = false;\nlet _isIOS = false;\nlet _locale = undefined;\nlet _language = LANGUAGE_DEFAULT;\nlet _translationsConfigFile = undefined;\nlet _userAgent = undefined;\nexport const globals = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});\nlet nodeProcess = undefined;\nif (typeof globals.vscode !== 'undefined' && typeof globals.vscode.process !== 'undefined') {\n    // Native environment (sandboxed)\n    nodeProcess = globals.vscode.process;\n}\nelse if (typeof process !== 'undefined') {\n    // Native environment (non-sandboxed)\n    nodeProcess = process;\n}\nconst isElectronProcess = typeof ((_a = nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.versions) === null || _a === void 0 ? void 0 : _a.electron) === 'string';\nconst isElectronRenderer = isElectronProcess && (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.type) === 'renderer';\n// Web environment\nif (typeof navigator === 'object' && !isElectronRenderer) {\n    _userAgent = navigator.userAgent;\n    _isWindows = _userAgent.indexOf('Windows') >= 0;\n    _isMacintosh = _userAgent.indexOf('Macintosh') >= 0;\n    _isIOS = (_userAgent.indexOf('Macintosh') >= 0 || _userAgent.indexOf('iPad') >= 0 || _userAgent.indexOf('iPhone') >= 0) && !!navigator.maxTouchPoints && navigator.maxTouchPoints > 0;\n    _isLinux = _userAgent.indexOf('Linux') >= 0;\n    _isWeb = true;\n    _locale = navigator.language;\n    _language = _locale;\n}\n// Native environment\nelse if (typeof nodeProcess === 'object') {\n    _isWindows = (nodeProcess.platform === 'win32');\n    _isMacintosh = (nodeProcess.platform === 'darwin');\n    _isLinux = (nodeProcess.platform === 'linux');\n    _isLinuxSnap = _isLinux && !!nodeProcess.env['SNAP'] && !!nodeProcess.env['SNAP_REVISION'];\n    _isElectron = isElectronProcess;\n    _locale = LANGUAGE_DEFAULT;\n    _language = LANGUAGE_DEFAULT;\n    const rawNlsConfig = nodeProcess.env['VSCODE_NLS_CONFIG'];\n    if (rawNlsConfig) {\n        try {\n            const nlsConfig = JSON.parse(rawNlsConfig);\n            const resolved = nlsConfig.availableLanguages['*'];\n            _locale = nlsConfig.locale;\n            // VSCode's default language is 'en'\n            _language = resolved ? resolved : LANGUAGE_DEFAULT;\n            _translationsConfigFile = nlsConfig._translationsConfigFile;\n        }\n        catch (e) {\n        }\n    }\n    _isNative = true;\n}\n// Unknown environment\nelse {\n    console.error('Unable to resolve platform.');\n}\nlet _platform = 0 /* Web */;\nif (_isMacintosh) {\n    _platform = 1 /* Mac */;\n}\nelse if (_isWindows) {\n    _platform = 3 /* Windows */;\n}\nelse if (_isLinux) {\n    _platform = 2 /* Linux */;\n}\nexport const isWindows = _isWindows;\nexport const isMacintosh = _isMacintosh;\nexport const isLinux = _isLinux;\nexport const isNative = _isNative;\nexport const isWeb = _isWeb;\nexport const isIOS = _isIOS;\nexport const userAgent = _userAgent;\n/**\n * The language used for the user interface. The format of\n * the string is all lower case (e.g. zh-tw for Traditional\n * Chinese)\n */\nexport const language = _language;\n/**\n * The OS locale or the locale specified by --locale. The format of\n * the string is all lower case (e.g. zh-tw for Traditional\n * Chinese). The UI is not necessarily shown in the provided locale.\n */\nexport const locale = _locale;\n/**\n * See https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#:~:text=than%204%2C%20then-,set%20timeout%20to%204,-.\n *\n * Works similarly to `setTimeout(0)` but doesn't suffer from the 4ms artificial delay\n * that browsers set when the nesting level is > 5.\n */\nexport const setTimeout0 = (() => {\n    if (typeof globals.postMessage === 'function' && !globals.importScripts) {\n        let pending = [];\n        globals.addEventListener('message', (e) => {\n            if (e.data && e.data.vscodeScheduleAsyncWork) {\n                for (let i = 0, len = pending.length; i < len; i++) {\n                    const candidate = pending[i];\n                    if (candidate.id === e.data.vscodeScheduleAsyncWork) {\n                        pending.splice(i, 1);\n                        candidate.callback();\n                        return;\n                    }\n                }\n            }\n        });\n        let lastId = 0;\n        return (callback) => {\n            const myId = ++lastId;\n            pending.push({\n                id: myId,\n                callback: callback\n            });\n            globals.postMessage({ vscodeScheduleAsyncWork: myId }, '*');\n        };\n    }\n    return (callback) => setTimeout(callback);\n})();\nexport const setImmediate = (function defineSetImmediate() {\n    if (globals.setImmediate) {\n        return globals.setImmediate.bind(globals);\n    }\n    if (typeof globals.postMessage === 'function' && !globals.importScripts) {\n        return setTimeout0;\n    }\n    if (typeof (nodeProcess === null || nodeProcess === void 0 ? void 0 : nodeProcess.nextTick) === 'function') {\n        return nodeProcess.nextTick.bind(nodeProcess);\n    }\n    const _promise = Promise.resolve();\n    return (callback) => _promise.then(callback);\n})();\nexport const OS = (_isMacintosh || _isIOS ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));\nlet _isLittleEndian = true;\nlet _isLittleEndianComputed = false;\nexport function isLittleEndian() {\n    if (!_isLittleEndianComputed) {\n        _isLittleEndianComputed = true;\n        const test = new Uint8Array(2);\n        test[0] = 1;\n        test[1] = 2;\n        const view = new Uint16Array(test.buffer);\n        _isLittleEndian = (view[0] === (2 << 8) + 1);\n    }\n    return _isLittleEndian;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass Node {\n    constructor(element) {\n        this.element = element;\n        this.next = Node.Undefined;\n        this.prev = Node.Undefined;\n    }\n}\nNode.Undefined = new Node(undefined);\nexport class LinkedList {\n    constructor() {\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    }\n    get size() {\n        return this._size;\n    }\n    isEmpty() {\n        return this._first === Node.Undefined;\n    }\n    clear() {\n        let node = this._first;\n        while (node !== Node.Undefined) {\n            const next = node.next;\n            node.prev = Node.Undefined;\n            node.next = Node.Undefined;\n            node = next;\n        }\n        this._first = Node.Undefined;\n        this._last = Node.Undefined;\n        this._size = 0;\n    }\n    unshift(element) {\n        return this._insert(element, false);\n    }\n    push(element) {\n        return this._insert(element, true);\n    }\n    _insert(element, atTheEnd) {\n        const newNode = new Node(element);\n        if (this._first === Node.Undefined) {\n            this._first = newNode;\n            this._last = newNode;\n        }\n        else if (atTheEnd) {\n            // push\n            const oldLast = this._last;\n            this._last = newNode;\n            newNode.prev = oldLast;\n            oldLast.next = newNode;\n        }\n        else {\n            // unshift\n            const oldFirst = this._first;\n            this._first = newNode;\n            newNode.next = oldFirst;\n            oldFirst.prev = newNode;\n        }\n        this._size += 1;\n        let didRemove = false;\n        return () => {\n            if (!didRemove) {\n                didRemove = true;\n                this._remove(newNode);\n            }\n        };\n    }\n    shift() {\n        if (this._first === Node.Undefined) {\n            return undefined;\n        }\n        else {\n            const res = this._first.element;\n            this._remove(this._first);\n            return res;\n        }\n    }\n    pop() {\n        if (this._last === Node.Undefined) {\n            return undefined;\n        }\n        else {\n            const res = this._last.element;\n            this._remove(this._last);\n            return res;\n        }\n    }\n    _remove(node) {\n        if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {\n            // middle\n            const anchor = node.prev;\n            anchor.next = node.next;\n            node.next.prev = anchor;\n        }\n        else if (node.prev === Node.Undefined && node.next === Node.Undefined) {\n            // only node\n            this._first = Node.Undefined;\n            this._last = Node.Undefined;\n        }\n        else if (node.next === Node.Undefined) {\n            // last\n            this._last = this._last.prev;\n            this._last.next = Node.Undefined;\n        }\n        else if (node.prev === Node.Undefined) {\n            // first\n            this._first = this._first.next;\n            this._first.prev = Node.Undefined;\n        }\n        // done\n        this._size -= 1;\n    }\n    *[Symbol.iterator]() {\n        let node = this._first;\n        while (node !== Node.Undefined) {\n            yield node.element;\n            node = node.next;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { globals } from './platform.js';\nconst hasPerformanceNow = (globals.performance && typeof globals.performance.now === 'function');\nexport class StopWatch {\n    constructor(highResolution) {\n        this._highResolution = hasPerformanceNow && highResolution;\n        this._startTime = this._now();\n        this._stopTime = -1;\n    }\n    static create(highResolution = true) {\n        return new StopWatch(highResolution);\n    }\n    stop() {\n        this._stopTime = this._now();\n    }\n    elapsed() {\n        if (this._stopTime !== -1) {\n            return this._stopTime - this._startTime;\n        }\n        return this._now() - this._startTime;\n    }\n    _now() {\n        return this._highResolution ? globals.performance.now() : Date.now();\n    }\n}\n","import { onUnexpectedError } from './errors.js';\nimport { combinedDisposable, Disposable, DisposableStore, toDisposable } from './lifecycle.js';\nimport { LinkedList } from './linkedList.js';\nimport { StopWatch } from './stopwatch.js';\nexport var Event;\n(function (Event) {\n    Event.None = () => Disposable.None;\n    /**\n     * Given an event, returns another event which only fires once.\n     */\n    function once(event) {\n        return (listener, thisArgs = null, disposables) => {\n            // we need this, in case the event fires during the listener call\n            let didFire = false;\n            let result;\n            result = event(e => {\n                if (didFire) {\n                    return;\n                }\n                else if (result) {\n                    result.dispose();\n                }\n                else {\n                    didFire = true;\n                }\n                return listener.call(thisArgs, e);\n            }, null, disposables);\n            if (didFire) {\n                result.dispose();\n            }\n            return result;\n        };\n    }\n    Event.once = once;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function map(event, map) {\n        return snapshot((listener, thisArgs = null, disposables) => event(i => listener.call(thisArgs, map(i)), null, disposables));\n    }\n    Event.map = map;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function forEach(event, each) {\n        return snapshot((listener, thisArgs = null, disposables) => event(i => { each(i); listener.call(thisArgs, i); }, null, disposables));\n    }\n    Event.forEach = forEach;\n    function filter(event, filter) {\n        return snapshot((listener, thisArgs = null, disposables) => event(e => filter(e) && listener.call(thisArgs, e), null, disposables));\n    }\n    Event.filter = filter;\n    /**\n     * Given an event, returns the same event but typed as `Event<void>`.\n     */\n    function signal(event) {\n        return event;\n    }\n    Event.signal = signal;\n    function any(...events) {\n        return (listener, thisArgs = null, disposables) => combinedDisposable(...events.map(event => event(e => listener.call(thisArgs, e), null, disposables)));\n    }\n    Event.any = any;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function reduce(event, merge, initial) {\n        let output = initial;\n        return map(event, e => {\n            output = merge(output, e);\n            return output;\n        });\n    }\n    Event.reduce = reduce;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function snapshot(event) {\n        let listener;\n        const emitter = new Emitter({\n            onFirstListenerAdd() {\n                listener = event(emitter.fire, emitter);\n            },\n            onLastListenerRemove() {\n                listener.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function debounce(event, merge, delay = 100, leading = false, leakWarningThreshold) {\n        let subscription;\n        let output = undefined;\n        let handle = undefined;\n        let numDebouncedCalls = 0;\n        const emitter = new Emitter({\n            leakWarningThreshold,\n            onFirstListenerAdd() {\n                subscription = event(cur => {\n                    numDebouncedCalls++;\n                    output = merge(output, cur);\n                    if (leading && !handle) {\n                        emitter.fire(output);\n                        output = undefined;\n                    }\n                    clearTimeout(handle);\n                    handle = setTimeout(() => {\n                        const _output = output;\n                        output = undefined;\n                        handle = undefined;\n                        if (!leading || numDebouncedCalls > 1) {\n                            emitter.fire(_output);\n                        }\n                        numDebouncedCalls = 0;\n                    }, delay);\n                });\n            },\n            onLastListenerRemove() {\n                subscription.dispose();\n            }\n        });\n        return emitter.event;\n    }\n    Event.debounce = debounce;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function latch(event, equals = (a, b) => a === b) {\n        let firstCall = true;\n        let cache;\n        return filter(event, value => {\n            const shouldEmit = firstCall || !equals(value, cache);\n            firstCall = false;\n            cache = value;\n            return shouldEmit;\n        });\n    }\n    Event.latch = latch;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function split(event, isT) {\n        return [\n            Event.filter(event, isT),\n            Event.filter(event, e => !isT(e)),\n        ];\n    }\n    Event.split = split;\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function buffer(event, flushAfterTimeout = false, _buffer = []) {\n        let buffer = _buffer.slice();\n        let listener = event(e => {\n            if (buffer) {\n                buffer.push(e);\n            }\n            else {\n                emitter.fire(e);\n            }\n        });\n        const flush = () => {\n            if (buffer) {\n                buffer.forEach(e => emitter.fire(e));\n            }\n            buffer = null;\n        };\n        const emitter = new Emitter({\n            onFirstListenerAdd() {\n                if (!listener) {\n                    listener = event(e => emitter.fire(e));\n                }\n            },\n            onFirstListenerDidAdd() {\n                if (buffer) {\n                    if (flushAfterTimeout) {\n                        setTimeout(flush);\n                    }\n                    else {\n                        flush();\n                    }\n                }\n            },\n            onLastListenerRemove() {\n                if (listener) {\n                    listener.dispose();\n                }\n                listener = null;\n            }\n        });\n        return emitter.event;\n    }\n    Event.buffer = buffer;\n    class ChainableEvent {\n        constructor(event) {\n            this.event = event;\n        }\n        map(fn) {\n            return new ChainableEvent(map(this.event, fn));\n        }\n        forEach(fn) {\n            return new ChainableEvent(forEach(this.event, fn));\n        }\n        filter(fn) {\n            return new ChainableEvent(filter(this.event, fn));\n        }\n        reduce(merge, initial) {\n            return new ChainableEvent(reduce(this.event, merge, initial));\n        }\n        latch() {\n            return new ChainableEvent(latch(this.event));\n        }\n        debounce(merge, delay = 100, leading = false, leakWarningThreshold) {\n            return new ChainableEvent(debounce(this.event, merge, delay, leading, leakWarningThreshold));\n        }\n        on(listener, thisArgs, disposables) {\n            return this.event(listener, thisArgs, disposables);\n        }\n        once(listener, thisArgs, disposables) {\n            return once(this.event)(listener, thisArgs, disposables);\n        }\n    }\n    /**\n     * @deprecated DO NOT use, this leaks memory\n     */\n    function chain(event) {\n        return new ChainableEvent(event);\n    }\n    Event.chain = chain;\n    function fromNodeEventEmitter(emitter, eventName, map = id => id) {\n        const fn = (...args) => result.fire(map(...args));\n        const onFirstListenerAdd = () => emitter.on(eventName, fn);\n        const onLastListenerRemove = () => emitter.removeListener(eventName, fn);\n        const result = new Emitter({ onFirstListenerAdd, onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromNodeEventEmitter = fromNodeEventEmitter;\n    function fromDOMEventEmitter(emitter, eventName, map = id => id) {\n        const fn = (...args) => result.fire(map(...args));\n        const onFirstListenerAdd = () => emitter.addEventListener(eventName, fn);\n        const onLastListenerRemove = () => emitter.removeEventListener(eventName, fn);\n        const result = new Emitter({ onFirstListenerAdd, onLastListenerRemove });\n        return result.event;\n    }\n    Event.fromDOMEventEmitter = fromDOMEventEmitter;\n    function toPromise(event) {\n        return new Promise(resolve => once(event)(resolve));\n    }\n    Event.toPromise = toPromise;\n})(Event || (Event = {}));\nclass EventProfiling {\n    constructor(name) {\n        this._listenerCount = 0;\n        this._invocationCount = 0;\n        this._elapsedOverall = 0;\n        this._name = `${name}_${EventProfiling._idPool++}`;\n    }\n    start(listenerCount) {\n        this._stopWatch = new StopWatch(true);\n        this._listenerCount = listenerCount;\n    }\n    stop() {\n        if (this._stopWatch) {\n            const elapsed = this._stopWatch.elapsed();\n            this._elapsedOverall += elapsed;\n            this._invocationCount += 1;\n            console.info(`did FIRE ${this._name}: elapsed_ms: ${elapsed.toFixed(5)}, listener: ${this._listenerCount} (elapsed_overall: ${this._elapsedOverall.toFixed(2)}, invocations: ${this._invocationCount})`);\n            this._stopWatch = undefined;\n        }\n    }\n}\nEventProfiling._idPool = 0;\nlet _globalLeakWarningThreshold = -1;\nclass LeakageMonitor {\n    constructor(customThreshold, name = Math.random().toString(18).slice(2, 5)) {\n        this.customThreshold = customThreshold;\n        this.name = name;\n        this._warnCountdown = 0;\n    }\n    dispose() {\n        if (this._stacks) {\n            this._stacks.clear();\n        }\n    }\n    check(listenerCount) {\n        let threshold = _globalLeakWarningThreshold;\n        if (typeof this.customThreshold === 'number') {\n            threshold = this.customThreshold;\n        }\n        if (threshold <= 0 || listenerCount < threshold) {\n            return undefined;\n        }\n        if (!this._stacks) {\n            this._stacks = new Map();\n        }\n        const stack = new Error().stack.split('\\n').slice(3).join('\\n');\n        const count = (this._stacks.get(stack) || 0);\n        this._stacks.set(stack, count + 1);\n        this._warnCountdown -= 1;\n        if (this._warnCountdown <= 0) {\n            // only warn on first exceed and then every time the limit\n            // is exceeded by 50% again\n            this._warnCountdown = threshold * 0.5;\n            // find most frequent listener and print warning\n            let topStack;\n            let topCount = 0;\n            for (const [stack, count] of this._stacks) {\n                if (!topStack || topCount < count) {\n                    topStack = stack;\n                    topCount = count;\n                }\n            }\n            console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`);\n            console.warn(topStack);\n        }\n        return () => {\n            const count = (this._stacks.get(stack) || 0);\n            this._stacks.set(stack, count - 1);\n        };\n    }\n}\n/**\n * The Emitter can be used to expose an Event to the public\n * to fire it from the insides.\n * Sample:\n    class Document {\n\n        private readonly _onDidChange = new Emitter<(value:string)=>any>();\n\n        public onDidChange = this._onDidChange.event;\n\n        // getter-style\n        // get onDidChange(): Event<(value:string)=>any> {\n        // \treturn this._onDidChange.event;\n        // }\n\n        private _doIt() {\n            //...\n            this._onDidChange.fire(value);\n        }\n    }\n */\nexport class Emitter {\n    constructor(options) {\n        var _a;\n        this._disposed = false;\n        this._options = options;\n        this._leakageMon = _globalLeakWarningThreshold > 0 ? new LeakageMonitor(this._options && this._options.leakWarningThreshold) : undefined;\n        this._perfMon = ((_a = this._options) === null || _a === void 0 ? void 0 : _a._profName) ? new EventProfiling(this._options._profName) : undefined;\n    }\n    /**\n     * For the public to allow to subscribe\n     * to events from this Emitter\n     */\n    get event() {\n        if (!this._event) {\n            this._event = (listener, thisArgs, disposables) => {\n                var _a;\n                if (!this._listeners) {\n                    this._listeners = new LinkedList();\n                }\n                const firstListener = this._listeners.isEmpty();\n                if (firstListener && this._options && this._options.onFirstListenerAdd) {\n                    this._options.onFirstListenerAdd(this);\n                }\n                const remove = this._listeners.push(!thisArgs ? listener : [listener, thisArgs]);\n                if (firstListener && this._options && this._options.onFirstListenerDidAdd) {\n                    this._options.onFirstListenerDidAdd(this);\n                }\n                if (this._options && this._options.onListenerDidAdd) {\n                    this._options.onListenerDidAdd(this, listener, thisArgs);\n                }\n                // check and record this emitter for potential leakage\n                const removeMonitor = (_a = this._leakageMon) === null || _a === void 0 ? void 0 : _a.check(this._listeners.size);\n                const result = toDisposable(() => {\n                    if (removeMonitor) {\n                        removeMonitor();\n                    }\n                    if (!this._disposed) {\n                        remove();\n                        if (this._options && this._options.onLastListenerRemove) {\n                            const hasListeners = (this._listeners && !this._listeners.isEmpty());\n                            if (!hasListeners) {\n                                this._options.onLastListenerRemove(this);\n                            }\n                        }\n                    }\n                });\n                if (disposables instanceof DisposableStore) {\n                    disposables.add(result);\n                }\n                else if (Array.isArray(disposables)) {\n                    disposables.push(result);\n                }\n                return result;\n            };\n        }\n        return this._event;\n    }\n    /**\n     * To be kept private to fire an event to\n     * subscribers\n     */\n    fire(event) {\n        var _a, _b;\n        if (this._listeners) {\n            // put all [listener,event]-pairs into delivery queue\n            // then emit all event. an inner/nested event might be\n            // the driver of this\n            if (!this._deliveryQueue) {\n                this._deliveryQueue = new LinkedList();\n            }\n            for (let listener of this._listeners) {\n                this._deliveryQueue.push([listener, event]);\n            }\n            // start/stop performance insight collection\n            (_a = this._perfMon) === null || _a === void 0 ? void 0 : _a.start(this._deliveryQueue.size);\n            while (this._deliveryQueue.size > 0) {\n                const [listener, event] = this._deliveryQueue.shift();\n                try {\n                    if (typeof listener === 'function') {\n                        listener.call(undefined, event);\n                    }\n                    else {\n                        listener[0].call(listener[1], event);\n                    }\n                }\n                catch (e) {\n                    onUnexpectedError(e);\n                }\n            }\n            (_b = this._perfMon) === null || _b === void 0 ? void 0 : _b.stop();\n        }\n    }\n    dispose() {\n        var _a, _b, _c, _d, _e;\n        if (!this._disposed) {\n            this._disposed = true;\n            (_a = this._listeners) === null || _a === void 0 ? void 0 : _a.clear();\n            (_b = this._deliveryQueue) === null || _b === void 0 ? void 0 : _b.clear();\n            (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.onLastListenerRemove) === null || _d === void 0 ? void 0 : _d.call(_c);\n            (_e = this._leakageMon) === null || _e === void 0 ? void 0 : _e.dispose();\n        }\n    }\n}\nexport class PauseableEmitter extends Emitter {\n    constructor(options) {\n        super(options);\n        this._isPaused = 0;\n        this._eventQueue = new LinkedList();\n        this._mergeFn = options === null || options === void 0 ? void 0 : options.merge;\n    }\n    pause() {\n        this._isPaused++;\n    }\n    resume() {\n        if (this._isPaused !== 0 && --this._isPaused === 0) {\n            if (this._mergeFn) {\n                // use the merge function to create a single composite\n                // event. make a copy in case firing pauses this emitter\n                const events = Array.from(this._eventQueue);\n                this._eventQueue.clear();\n                super.fire(this._mergeFn(events));\n            }\n            else {\n                // no merging, fire each event individually and test\n                // that this emitter isn't paused halfway through\n                while (!this._isPaused && this._eventQueue.size !== 0) {\n                    super.fire(this._eventQueue.shift());\n                }\n            }\n        }\n    }\n    fire(event) {\n        if (this._listeners) {\n            if (this._isPaused !== 0) {\n                this._eventQueue.push(event);\n            }\n            else {\n                super.fire(event);\n            }\n        }\n    }\n}\nexport class DebounceEmitter extends PauseableEmitter {\n    constructor(options) {\n        var _a;\n        super(options);\n        this._delay = (_a = options.delay) !== null && _a !== void 0 ? _a : 100;\n    }\n    fire(event) {\n        if (!this._handle) {\n            this.pause();\n            this._handle = setTimeout(() => {\n                this._handle = undefined;\n                this.resume();\n            }, this._delay);\n        }\n        super.fire(event);\n    }\n}\n/**\n * The EventBufferer is useful in situations in which you want\n * to delay firing your events during some code.\n * You can wrap that code and be sure that the event will not\n * be fired during that wrap.\n *\n * ```\n * const emitter: Emitter;\n * const delayer = new EventDelayer();\n * const delayedEvent = delayer.wrapEvent(emitter.event);\n *\n * delayedEvent(console.log);\n *\n * delayer.bufferEvents(() => {\n *   emitter.fire(); // event will not be fired yet\n * });\n *\n * // event will only be fired at this point\n * ```\n */\nexport class EventBufferer {\n    constructor() {\n        this.buffers = [];\n    }\n    wrapEvent(event) {\n        return (listener, thisArgs, disposables) => {\n            return event(i => {\n                const buffer = this.buffers[this.buffers.length - 1];\n                if (buffer) {\n                    buffer.push(() => listener.call(thisArgs, i));\n                }\n                else {\n                    listener.call(thisArgs, i);\n                }\n            }, undefined, disposables);\n        };\n    }\n    bufferEvents(fn) {\n        const buffer = [];\n        this.buffers.push(buffer);\n        const r = fn();\n        this.buffers.pop();\n        buffer.forEach(flush => flush());\n        return r;\n    }\n}\n/**\n * A Relay is an event forwarder which functions as a replugabble event pipe.\n * Once created, you can connect an input event to it and it will simply forward\n * events from that input event through its own `event` property. The `input`\n * can be changed at any point in time.\n */\nexport class Relay {\n    constructor() {\n        this.listening = false;\n        this.inputEvent = Event.None;\n        this.inputEventListener = Disposable.None;\n        this.emitter = new Emitter({\n            onFirstListenerDidAdd: () => {\n                this.listening = true;\n                this.inputEventListener = this.inputEvent(this.emitter.fire, this.emitter);\n            },\n            onLastListenerRemove: () => {\n                this.listening = false;\n                this.inputEventListener.dispose();\n            }\n        });\n        this.event = this.emitter.event;\n    }\n    set input(event) {\n        this.inputEvent = event;\n        if (this.listening) {\n            this.inputEventListener.dispose();\n            this.inputEventListener = event(this.emitter.fire, this.emitter);\n        }\n    }\n    dispose() {\n        this.inputEventListener.dispose();\n        this.emitter.dispose();\n    }\n}\n","/**\n * @returns whether the provided parameter is a JavaScript Array or not.\n */\nexport function isArray(array) {\n    return Array.isArray(array);\n}\n/**\n * @returns whether the provided parameter is a JavaScript String or not.\n */\nexport function isString(str) {\n    return (typeof str === 'string');\n}\n/**\n *\n * @returns whether the provided parameter is of type `object` but **not**\n *\t`null`, an `array`, a `regexp`, nor a `date`.\n */\nexport function isObject(obj) {\n    // The method can't do a type cast since there are type (like strings) which\n    // are subclasses of any put not positvely matched by the function. Hence type\n    // narrowing results in wrong results.\n    return typeof obj === 'object'\n        && obj !== null\n        && !Array.isArray(obj)\n        && !(obj instanceof RegExp)\n        && !(obj instanceof Date);\n}\n/**\n * In **contrast** to just checking `typeof` this will return `false` for `NaN`.\n * @returns whether the provided parameter is a JavaScript Number or not.\n */\nexport function isNumber(obj) {\n    return (typeof obj === 'number' && !isNaN(obj));\n}\n/**\n * @returns whether the provided parameter is a JavaScript Boolean or not.\n */\nexport function isBoolean(obj) {\n    return (obj === true || obj === false);\n}\n/**\n * @returns whether the provided parameter is undefined.\n */\nexport function isUndefined(obj) {\n    return (typeof obj === 'undefined');\n}\n/**\n * @returns whether the provided parameter is defined.\n */\nexport function isDefined(arg) {\n    return !isUndefinedOrNull(arg);\n}\n/**\n * @returns whether the provided parameter is undefined or null.\n */\nexport function isUndefinedOrNull(obj) {\n    return (isUndefined(obj) || obj === null);\n}\nexport function assertType(condition, type) {\n    if (!condition) {\n        throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');\n    }\n}\n/**\n * Asserts that the argument passed in is neither undefined nor null.\n */\nexport function assertIsDefined(arg) {\n    if (isUndefinedOrNull(arg)) {\n        throw new Error('Assertion Failed: argument is undefined or null');\n    }\n    return arg;\n}\n/**\n * @returns whether the provided parameter is a JavaScript Function or not.\n */\nexport function isFunction(obj) {\n    return (typeof obj === 'function');\n}\nexport function validateConstraints(args, constraints) {\n    const len = Math.min(args.length, constraints.length);\n    for (let i = 0; i < len; i++) {\n        validateConstraint(args[i], constraints[i]);\n    }\n}\nexport function validateConstraint(arg, constraint) {\n    if (isString(constraint)) {\n        if (typeof arg !== constraint) {\n            throw new Error(`argument does not match constraint: typeof ${constraint}`);\n        }\n    }\n    else if (isFunction(constraint)) {\n        try {\n            if (arg instanceof constraint) {\n                return;\n            }\n        }\n        catch (_a) {\n            // ignore\n        }\n        if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {\n            return;\n        }\n        if (constraint.length === 1 && constraint.call(undefined, arg) === true) {\n            return;\n        }\n        throw new Error(`argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true`);\n    }\n}\nexport function getAllPropertyNames(obj) {\n    let res = [];\n    let proto = Object.getPrototypeOf(obj);\n    while (Object.prototype !== proto) {\n        res = res.concat(Object.getOwnPropertyNames(proto));\n        proto = Object.getPrototypeOf(proto);\n    }\n    return res;\n}\nexport function getAllMethodNames(obj) {\n    const methods = [];\n    for (const prop of getAllPropertyNames(obj)) {\n        if (typeof obj[prop] === 'function') {\n            methods.push(prop);\n        }\n    }\n    return methods;\n}\nexport function createProxyObject(methodNames, invoke) {\n    const createProxyMethod = (method) => {\n        return function () {\n            const args = Array.prototype.slice.call(arguments, 0);\n            return invoke(method, args);\n        };\n    };\n    let result = {};\n    for (const methodName of methodNames) {\n        result[methodName] = createProxyMethod(methodName);\n    }\n    return result;\n}\n/**\n * Converts null to undefined, passes all other values through.\n */\nexport function withNullAsUndefined(x) {\n    return x === null ? undefined : x;\n}\nexport function assertNever(value, message = 'Unreachable') {\n    throw new Error(message);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as platform from './platform.js';\nexport function isFalsyOrWhitespace(str) {\n    if (!str || typeof str !== 'string') {\n        return true;\n    }\n    return str.trim().length === 0;\n}\nconst _formatRegexp = /{(\\d+)}/g;\n/**\n * Helper to produce a string with a variable number of arguments. Insert variable segments\n * into the string using the {n} notation where N is the index of the argument following the string.\n * @param value string to which formatting is applied\n * @param args replacements for {n}-entries\n */\nexport function format(value, ...args) {\n    if (args.length === 0) {\n        return value;\n    }\n    return value.replace(_formatRegexp, function (match, group) {\n        const idx = parseInt(group, 10);\n        return isNaN(idx) || idx < 0 || idx >= args.length ?\n            match :\n            args[idx];\n    });\n}\n/**\n * Converts HTML characters inside the string to use entities instead. Makes the string safe from\n * being used e.g. in HTMLElement.innerHTML.\n */\nexport function escape(html) {\n    return html.replace(/[<>&]/g, function (match) {\n        switch (match) {\n            case '<': return '&lt;';\n            case '>': return '&gt;';\n            case '&': return '&amp;';\n            default: return match;\n        }\n    });\n}\n/**\n * Escapes regular expression characters in a given string\n */\nexport function escapeRegExpCharacters(value) {\n    return value.replace(/[\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\[\\]\\(\\)]/g, '\\\\$&');\n}\n/**\n * Removes all occurrences of needle from the beginning and end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim (default is a blank)\n */\nexport function trim(haystack, needle = ' ') {\n    const trimmed = ltrim(haystack, needle);\n    return rtrim(trimmed, needle);\n}\n/**\n * Removes all occurrences of needle from the beginning of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function ltrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    const needleLen = needle.length;\n    if (needleLen === 0 || haystack.length === 0) {\n        return haystack;\n    }\n    let offset = 0;\n    while (haystack.indexOf(needle, offset) === offset) {\n        offset = offset + needleLen;\n    }\n    return haystack.substring(offset);\n}\n/**\n * Removes all occurrences of needle from the end of haystack.\n * @param haystack string to trim\n * @param needle the thing to trim\n */\nexport function rtrim(haystack, needle) {\n    if (!haystack || !needle) {\n        return haystack;\n    }\n    const needleLen = needle.length, haystackLen = haystack.length;\n    if (needleLen === 0 || haystackLen === 0) {\n        return haystack;\n    }\n    let offset = haystackLen, idx = -1;\n    while (true) {\n        idx = haystack.lastIndexOf(needle, offset - 1);\n        if (idx === -1 || idx + needleLen !== offset) {\n            break;\n        }\n        if (idx === 0) {\n            return '';\n        }\n        offset = idx;\n    }\n    return haystack.substring(0, offset);\n}\nexport function convertSimple2RegExpPattern(pattern) {\n    return pattern.replace(/[\\-\\\\\\{\\}\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, '\\\\$&').replace(/[\\*]/g, '.*');\n}\nexport function stripWildcards(pattern) {\n    return pattern.replace(/\\*/g, '');\n}\nexport function createRegExp(searchString, isRegex, options = {}) {\n    if (!searchString) {\n        throw new Error('Cannot create regex from empty string');\n    }\n    if (!isRegex) {\n        searchString = escapeRegExpCharacters(searchString);\n    }\n    if (options.wholeWord) {\n        if (!/\\B/.test(searchString.charAt(0))) {\n            searchString = '\\\\b' + searchString;\n        }\n        if (!/\\B/.test(searchString.charAt(searchString.length - 1))) {\n            searchString = searchString + '\\\\b';\n        }\n    }\n    let modifiers = '';\n    if (options.global) {\n        modifiers += 'g';\n    }\n    if (!options.matchCase) {\n        modifiers += 'i';\n    }\n    if (options.multiline) {\n        modifiers += 'm';\n    }\n    if (options.unicode) {\n        modifiers += 'u';\n    }\n    return new RegExp(searchString, modifiers);\n}\nexport function regExpLeadsToEndlessLoop(regexp) {\n    // Exit early if it's one of these special cases which are meant to match\n    // against an empty string\n    if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$' || regexp.source === '^\\\\s*$') {\n        return false;\n    }\n    // We check against an empty string. If the regular expression doesn't advance\n    // (e.g. ends in an endless loop) it will match an empty string.\n    const match = regexp.exec('');\n    return !!(match && regexp.lastIndex === 0);\n}\nexport function regExpFlags(regexp) {\n    return (regexp.global ? 'g' : '')\n        + (regexp.ignoreCase ? 'i' : '')\n        + (regexp.multiline ? 'm' : '')\n        + (regexp /* standalone editor compilation */.unicode ? 'u' : '');\n}\nexport function splitLines(str) {\n    return str.split(/\\r\\n|\\r|\\n/);\n}\n/**\n * Returns first index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function firstNonWhitespaceIndex(str) {\n    for (let i = 0, len = str.length; i < len; i++) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\n/**\n * Returns the leading whitespace of the string.\n * If the string contains only whitespaces, returns entire string\n */\nexport function getLeadingWhitespace(str, start = 0, end = str.length) {\n    for (let i = start; i < end; i++) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return str.substring(start, i);\n        }\n    }\n    return str.substring(start, end);\n}\n/**\n * Returns last index of the string that is not whitespace.\n * If string is empty or contains only whitespaces, returns -1\n */\nexport function lastNonWhitespaceIndex(str, startIndex = str.length - 1) {\n    for (let i = startIndex; i >= 0; i--) {\n        const chCode = str.charCodeAt(i);\n        if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {\n            return i;\n        }\n    }\n    return -1;\n}\nexport function compare(a, b) {\n    if (a < b) {\n        return -1;\n    }\n    else if (a > b) {\n        return 1;\n    }\n    else {\n        return 0;\n    }\n}\nexport function compareSubstring(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n    for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n        let codeA = a.charCodeAt(aStart);\n        let codeB = b.charCodeAt(bStart);\n        if (codeA < codeB) {\n            return -1;\n        }\n        else if (codeA > codeB) {\n            return 1;\n        }\n    }\n    const aLen = aEnd - aStart;\n    const bLen = bEnd - bStart;\n    if (aLen < bLen) {\n        return -1;\n    }\n    else if (aLen > bLen) {\n        return 1;\n    }\n    return 0;\n}\nexport function compareIgnoreCase(a, b) {\n    return compareSubstringIgnoreCase(a, b, 0, a.length, 0, b.length);\n}\nexport function compareSubstringIgnoreCase(a, b, aStart = 0, aEnd = a.length, bStart = 0, bEnd = b.length) {\n    for (; aStart < aEnd && bStart < bEnd; aStart++, bStart++) {\n        let codeA = a.charCodeAt(aStart);\n        let codeB = b.charCodeAt(bStart);\n        if (codeA === codeB) {\n            // equal\n            continue;\n        }\n        if (codeA >= 128 || codeB >= 128) {\n            // not ASCII letters -> fallback to lower-casing strings\n            return compareSubstring(a.toLowerCase(), b.toLowerCase(), aStart, aEnd, bStart, bEnd);\n        }\n        // mapper lower-case ascii letter onto upper-case varinats\n        // [97-122] (lower ascii) --> [65-90] (upper ascii)\n        if (isLowerAsciiLetter(codeA)) {\n            codeA -= 32;\n        }\n        if (isLowerAsciiLetter(codeB)) {\n            codeB -= 32;\n        }\n        // compare both code points\n        const diff = codeA - codeB;\n        if (diff === 0) {\n            continue;\n        }\n        return diff;\n    }\n    const aLen = aEnd - aStart;\n    const bLen = bEnd - bStart;\n    if (aLen < bLen) {\n        return -1;\n    }\n    else if (aLen > bLen) {\n        return 1;\n    }\n    return 0;\n}\nexport function isLowerAsciiLetter(code) {\n    return code >= 97 /* a */ && code <= 122 /* z */;\n}\nexport function isUpperAsciiLetter(code) {\n    return code >= 65 /* A */ && code <= 90 /* Z */;\n}\nexport function equalsIgnoreCase(a, b) {\n    return a.length === b.length && compareSubstringIgnoreCase(a, b) === 0;\n}\nexport function startsWithIgnoreCase(str, candidate) {\n    const candidateLength = candidate.length;\n    if (candidate.length > str.length) {\n        return false;\n    }\n    return compareSubstringIgnoreCase(str, candidate, 0, candidateLength) === 0;\n}\n/**\n * @returns the length of the common prefix of the two strings.\n */\nexport function commonPrefixLength(a, b) {\n    let i, len = Math.min(a.length, b.length);\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(i) !== b.charCodeAt(i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * @returns the length of the common suffix of the two strings.\n */\nexport function commonSuffixLength(a, b) {\n    let i, len = Math.min(a.length, b.length);\n    const aLastIndex = a.length - 1;\n    const bLastIndex = b.length - 1;\n    for (i = 0; i < len; i++) {\n        if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {\n            return i;\n        }\n    }\n    return len;\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isHighSurrogate(charCode) {\n    return (0xD800 <= charCode && charCode <= 0xDBFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function isLowSurrogate(charCode) {\n    return (0xDC00 <= charCode && charCode <= 0xDFFF);\n}\n/**\n * See http://en.wikipedia.org/wiki/Surrogate_pair\n */\nexport function computeCodePoint(highSurrogate, lowSurrogate) {\n    return ((highSurrogate - 0xD800) << 10) + (lowSurrogate - 0xDC00) + 0x10000;\n}\n/**\n * get the code point that begins at offset `offset`\n */\nexport function getNextCodePoint(str, len, offset) {\n    const charCode = str.charCodeAt(offset);\n    if (isHighSurrogate(charCode) && offset + 1 < len) {\n        const nextCharCode = str.charCodeAt(offset + 1);\n        if (isLowSurrogate(nextCharCode)) {\n            return computeCodePoint(charCode, nextCharCode);\n        }\n    }\n    return charCode;\n}\n/**\n * get the code point that ends right before offset `offset`\n */\nfunction getPrevCodePoint(str, offset) {\n    const charCode = str.charCodeAt(offset - 1);\n    if (isLowSurrogate(charCode) && offset > 1) {\n        const prevCharCode = str.charCodeAt(offset - 2);\n        if (isHighSurrogate(prevCharCode)) {\n            return computeCodePoint(prevCharCode, charCode);\n        }\n    }\n    return charCode;\n}\nexport function nextCharLength(str, offset) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    const initialOffset = offset;\n    const len = str.length;\n    const initialCodePoint = getNextCodePoint(str, len, offset);\n    offset += (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n    let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\n    while (offset < len) {\n        const nextCodePoint = getNextCodePoint(str, len, offset);\n        const nextGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(nextCodePoint);\n        if (breakBetweenGraphemeBreakType(graphemeBreakType, nextGraphemeBreakType)) {\n            break;\n        }\n        offset += (nextCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n        graphemeBreakType = nextGraphemeBreakType;\n    }\n    return (offset - initialOffset);\n}\nexport function prevCharLength(str, offset) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    const initialOffset = offset;\n    const initialCodePoint = getPrevCodePoint(str, offset);\n    offset -= (initialCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n    let graphemeBreakType = graphemeBreakTree.getGraphemeBreakType(initialCodePoint);\n    while (offset > 0) {\n        const prevCodePoint = getPrevCodePoint(str, offset);\n        const prevGraphemeBreakType = graphemeBreakTree.getGraphemeBreakType(prevCodePoint);\n        if (breakBetweenGraphemeBreakType(prevGraphemeBreakType, graphemeBreakType)) {\n            break;\n        }\n        offset -= (prevCodePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1);\n        graphemeBreakType = prevGraphemeBreakType;\n    }\n    return (initialOffset - offset);\n}\n/**\n * Generated using https://github.com/alexdima/unicode-utils/blob/main/rtl-test.js\n */\nconst CONTAINS_RTL = /(?:[\\u05BE\\u05C0\\u05C3\\u05C6\\u05D0-\\u05F4\\u0608\\u060B\\u060D\\u061B-\\u064A\\u066D-\\u066F\\u0671-\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1-\\u07EA\\u07F4\\u07F5\\u07FA\\u07FE-\\u0815\\u081A\\u0824\\u0828\\u0830-\\u0858\\u085E-\\u088E\\u08A0-\\u08C9\\u200F\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFD3D\\uFD50-\\uFDC7\\uFDF0-\\uFDFC\\uFE70-\\uFEFC]|\\uD802[\\uDC00-\\uDD1B\\uDD20-\\uDE00\\uDE10-\\uDE35\\uDE40-\\uDEE4\\uDEEB-\\uDF35\\uDF40-\\uDFFF]|\\uD803[\\uDC00-\\uDD23\\uDE80-\\uDEA9\\uDEAD-\\uDF45\\uDF51-\\uDF81\\uDF86-\\uDFF6]|\\uD83A[\\uDC00-\\uDCCF\\uDD00-\\uDD43\\uDD4B-\\uDFFF]|\\uD83B[\\uDC00-\\uDEBB])/;\n/**\n * Returns true if `str` contains any Unicode character that is classified as \"R\" or \"AL\".\n */\nexport function containsRTL(str) {\n    return CONTAINS_RTL.test(str);\n}\n/**\n * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js\n */\nconst CONTAINS_EMOJI = /(?:[\\u231A\\u231B\\u23F0\\u23F3\\u2600-\\u27BF\\u2B50\\u2B55]|\\uD83C[\\uDDE6-\\uDDFF\\uDF00-\\uDFFF]|\\uD83D[\\uDC00-\\uDE4F\\uDE80-\\uDEFC\\uDFE0-\\uDFF0]|\\uD83E[\\uDD00-\\uDDFF\\uDE70-\\uDEF6])/;\nexport function containsEmoji(str) {\n    return CONTAINS_EMOJI.test(str);\n}\nconst IS_BASIC_ASCII = /^[\\t\\n\\r\\x20-\\x7E]*$/;\n/**\n * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \\n, \\r, \\t\n */\nexport function isBasicASCII(str) {\n    return IS_BASIC_ASCII.test(str);\n}\nexport const UNUSUAL_LINE_TERMINATORS = /[\\u2028\\u2029]/; // LINE SEPARATOR (LS) or PARAGRAPH SEPARATOR (PS)\n/**\n * Returns true if `str` contains unusual line terminators, like LS or PS\n */\nexport function containsUnusualLineTerminators(str) {\n    return UNUSUAL_LINE_TERMINATORS.test(str);\n}\nexport function containsFullWidthCharacter(str) {\n    for (let i = 0, len = str.length; i < len; i++) {\n        if (isFullWidthCharacter(str.charCodeAt(i))) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function isFullWidthCharacter(charCode) {\n    // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns\n    // http://jrgraphix.net/research/unicode_blocks.php\n    //          2E80 - 2EFF   CJK Radicals Supplement\n    //          2F00 - 2FDF   Kangxi Radicals\n    //          2FF0 - 2FFF   Ideographic Description Characters\n    //          3000 - 303F   CJK Symbols and Punctuation\n    //          3040 - 309F   Hiragana\n    //          30A0 - 30FF   Katakana\n    //          3100 - 312F   Bopomofo\n    //          3130 - 318F   Hangul Compatibility Jamo\n    //          3190 - 319F   Kanbun\n    //          31A0 - 31BF   Bopomofo Extended\n    //          31F0 - 31FF   Katakana Phonetic Extensions\n    //          3200 - 32FF   Enclosed CJK Letters and Months\n    //          3300 - 33FF   CJK Compatibility\n    //          3400 - 4DBF   CJK Unified Ideographs Extension A\n    //          4DC0 - 4DFF   Yijing Hexagram Symbols\n    //          4E00 - 9FFF   CJK Unified Ideographs\n    //          A000 - A48F   Yi Syllables\n    //          A490 - A4CF   Yi Radicals\n    //          AC00 - D7AF   Hangul Syllables\n    // [IGNORE] D800 - DB7F   High Surrogates\n    // [IGNORE] DB80 - DBFF   High Private Use Surrogates\n    // [IGNORE] DC00 - DFFF   Low Surrogates\n    // [IGNORE] E000 - F8FF   Private Use Area\n    //          F900 - FAFF   CJK Compatibility Ideographs\n    // [IGNORE] FB00 - FB4F   Alphabetic Presentation Forms\n    // [IGNORE] FB50 - FDFF   Arabic Presentation Forms-A\n    // [IGNORE] FE00 - FE0F   Variation Selectors\n    // [IGNORE] FE20 - FE2F   Combining Half Marks\n    // [IGNORE] FE30 - FE4F   CJK Compatibility Forms\n    // [IGNORE] FE50 - FE6F   Small Form Variants\n    // [IGNORE] FE70 - FEFF   Arabic Presentation Forms-B\n    //          FF00 - FFEF   Halfwidth and Fullwidth Forms\n    //               [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]\n    //               of which FF01 - FF5E fullwidth ASCII of 21 to 7E\n    // [IGNORE]    and FF65 - FFDC halfwidth of Katakana and Hangul\n    // [IGNORE] FFF0 - FFFF   Specials\n    return ((charCode >= 0x2E80 && charCode <= 0xD7AF)\n        || (charCode >= 0xF900 && charCode <= 0xFAFF)\n        || (charCode >= 0xFF01 && charCode <= 0xFF5E));\n}\n/**\n * A fast function (therefore imprecise) to check if code points are emojis.\n * Generated using https://github.com/alexdima/unicode-utils/blob/main/emoji-test.js\n */\nexport function isEmojiImprecise(x) {\n    return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)\n        || (x === 9203) || (x >= 9728 && x <= 10175) || (x === 11088) || (x === 11093)\n        || (x >= 127744 && x <= 128591) || (x >= 128640 && x <= 128764)\n        || (x >= 128992 && x <= 129008) || (x >= 129280 && x <= 129535)\n        || (x >= 129648 && x <= 129782));\n}\n// -- UTF-8 BOM\nexport const UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);\nexport function startsWithUTF8BOM(str) {\n    return !!(str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);\n}\nexport function containsUppercaseCharacter(target, ignoreEscapedChars = false) {\n    if (!target) {\n        return false;\n    }\n    if (ignoreEscapedChars) {\n        target = target.replace(/\\\\./g, '');\n    }\n    return target.toLowerCase() !== target;\n}\n/**\n * Produces 'a'-'z', followed by 'A'-'Z'... followed by 'a'-'z', etc.\n */\nexport function singleLetterHash(n) {\n    const LETTERS_CNT = (90 /* Z */ - 65 /* A */ + 1);\n    n = n % (2 * LETTERS_CNT);\n    if (n < LETTERS_CNT) {\n        return String.fromCharCode(97 /* a */ + n);\n    }\n    return String.fromCharCode(65 /* A */ + n - LETTERS_CNT);\n}\n//#region Unicode Grapheme Break\nexport function getGraphemeBreakType(codePoint) {\n    const graphemeBreakTree = GraphemeBreakTree.getInstance();\n    return graphemeBreakTree.getGraphemeBreakType(codePoint);\n}\nexport function breakBetweenGraphemeBreakType(breakTypeA, breakTypeB) {\n    // http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules\n    // !!! Let's make the common case a bit faster\n    if (breakTypeA === 0 /* Other */) {\n        // see https://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakTest-13.0.0d10.html#table\n        return (breakTypeB !== 5 /* Extend */ && breakTypeB !== 7 /* SpacingMark */);\n    }\n    // Do not break between a CR and LF. Otherwise, break before and after controls.\n    // GB3                                        CR × LF\n    // GB4                       (Control | CR | LF) ÷\n    // GB5                                           ÷ (Control | CR | LF)\n    if (breakTypeA === 2 /* CR */) {\n        if (breakTypeB === 3 /* LF */) {\n            return false; // GB3\n        }\n    }\n    if (breakTypeA === 4 /* Control */ || breakTypeA === 2 /* CR */ || breakTypeA === 3 /* LF */) {\n        return true; // GB4\n    }\n    if (breakTypeB === 4 /* Control */ || breakTypeB === 2 /* CR */ || breakTypeB === 3 /* LF */) {\n        return true; // GB5\n    }\n    // Do not break Hangul syllable sequences.\n    // GB6                                         L × (L | V | LV | LVT)\n    // GB7                                  (LV | V) × (V | T)\n    // GB8                                 (LVT | T) × T\n    if (breakTypeA === 8 /* L */) {\n        if (breakTypeB === 8 /* L */ || breakTypeB === 9 /* V */ || breakTypeB === 11 /* LV */ || breakTypeB === 12 /* LVT */) {\n            return false; // GB6\n        }\n    }\n    if (breakTypeA === 11 /* LV */ || breakTypeA === 9 /* V */) {\n        if (breakTypeB === 9 /* V */ || breakTypeB === 10 /* T */) {\n            return false; // GB7\n        }\n    }\n    if (breakTypeA === 12 /* LVT */ || breakTypeA === 10 /* T */) {\n        if (breakTypeB === 10 /* T */) {\n            return false; // GB8\n        }\n    }\n    // Do not break before extending characters or ZWJ.\n    // GB9                                           × (Extend | ZWJ)\n    if (breakTypeB === 5 /* Extend */ || breakTypeB === 13 /* ZWJ */) {\n        return false; // GB9\n    }\n    // The GB9a and GB9b rules only apply to extended grapheme clusters:\n    // Do not break before SpacingMarks, or after Prepend characters.\n    // GB9a                                          × SpacingMark\n    // GB9b                                  Prepend ×\n    if (breakTypeB === 7 /* SpacingMark */) {\n        return false; // GB9a\n    }\n    if (breakTypeA === 1 /* Prepend */) {\n        return false; // GB9b\n    }\n    // Do not break within emoji modifier sequences or emoji zwj sequences.\n    // GB11    \\p{Extended_Pictographic} Extend* ZWJ × \\p{Extended_Pictographic}\n    if (breakTypeA === 13 /* ZWJ */ && breakTypeB === 14 /* Extended_Pictographic */) {\n        // Note: we are not implementing the rule entirely here to avoid introducing states\n        return false; // GB11\n    }\n    // GB12                          sot (RI RI)* RI × RI\n    // GB13                        [^RI] (RI RI)* RI × RI\n    if (breakTypeA === 6 /* Regional_Indicator */ && breakTypeB === 6 /* Regional_Indicator */) {\n        // Note: we are not implementing the rule entirely here to avoid introducing states\n        return false; // GB12 & GB13\n    }\n    // GB999                                     Any ÷ Any\n    return true;\n}\nclass GraphemeBreakTree {\n    constructor() {\n        this._data = getGraphemeBreakRawData();\n    }\n    static getInstance() {\n        if (!GraphemeBreakTree._INSTANCE) {\n            GraphemeBreakTree._INSTANCE = new GraphemeBreakTree();\n        }\n        return GraphemeBreakTree._INSTANCE;\n    }\n    getGraphemeBreakType(codePoint) {\n        // !!! Let's make 7bit ASCII a bit faster: 0..31\n        if (codePoint < 32) {\n            if (codePoint === 10 /* LineFeed */) {\n                return 3 /* LF */;\n            }\n            if (codePoint === 13 /* CarriageReturn */) {\n                return 2 /* CR */;\n            }\n            return 4 /* Control */;\n        }\n        // !!! Let's make 7bit ASCII a bit faster: 32..126\n        if (codePoint < 127) {\n            return 0 /* Other */;\n        }\n        const data = this._data;\n        const nodeCount = data.length / 3;\n        let nodeIndex = 1;\n        while (nodeIndex <= nodeCount) {\n            if (codePoint < data[3 * nodeIndex]) {\n                // go left\n                nodeIndex = 2 * nodeIndex;\n            }\n            else if (codePoint > data[3 * nodeIndex + 1]) {\n                // go right\n                nodeIndex = 2 * nodeIndex + 1;\n            }\n            else {\n                // hit\n                return data[3 * nodeIndex + 2];\n            }\n        }\n        return 0 /* Other */;\n    }\n}\nGraphemeBreakTree._INSTANCE = null;\nfunction getGraphemeBreakRawData() {\n    // generated using https://github.com/alexdima/unicode-utils/blob/main/grapheme-break.js\n    return JSON.parse('[0,0,0,51229,51255,12,44061,44087,12,127462,127487,6,7083,7085,5,47645,47671,12,54813,54839,12,128678,128678,14,3270,3270,5,9919,9923,14,45853,45879,12,49437,49463,12,53021,53047,12,71216,71218,7,128398,128399,14,129360,129374,14,2519,2519,5,4448,4519,9,9742,9742,14,12336,12336,14,44957,44983,12,46749,46775,12,48541,48567,12,50333,50359,12,52125,52151,12,53917,53943,12,69888,69890,5,73018,73018,5,127990,127990,14,128558,128559,14,128759,128760,14,129653,129655,14,2027,2035,5,2891,2892,7,3761,3761,5,6683,6683,5,8293,8293,4,9825,9826,14,9999,9999,14,43452,43453,5,44509,44535,12,45405,45431,12,46301,46327,12,47197,47223,12,48093,48119,12,48989,49015,12,49885,49911,12,50781,50807,12,51677,51703,12,52573,52599,12,53469,53495,12,54365,54391,12,65279,65279,4,70471,70472,7,72145,72147,7,119173,119179,5,127799,127818,14,128240,128244,14,128512,128512,14,128652,128652,14,128721,128722,14,129292,129292,14,129445,129450,14,129734,129743,14,1476,1477,5,2366,2368,7,2750,2752,7,3076,3076,5,3415,3415,5,4141,4144,5,6109,6109,5,6964,6964,5,7394,7400,5,9197,9198,14,9770,9770,14,9877,9877,14,9968,9969,14,10084,10084,14,43052,43052,5,43713,43713,5,44285,44311,12,44733,44759,12,45181,45207,12,45629,45655,12,46077,46103,12,46525,46551,12,46973,46999,12,47421,47447,12,47869,47895,12,48317,48343,12,48765,48791,12,49213,49239,12,49661,49687,12,50109,50135,12,50557,50583,12,51005,51031,12,51453,51479,12,51901,51927,12,52349,52375,12,52797,52823,12,53245,53271,12,53693,53719,12,54141,54167,12,54589,54615,12,55037,55063,12,69506,69509,5,70191,70193,5,70841,70841,7,71463,71467,5,72330,72342,5,94031,94031,5,123628,123631,5,127763,127765,14,127941,127941,14,128043,128062,14,128302,128317,14,128465,128467,14,128539,128539,14,128640,128640,14,128662,128662,14,128703,128703,14,128745,128745,14,129004,129007,14,129329,129330,14,129402,129402,14,129483,129483,14,129686,129704,14,130048,131069,14,173,173,4,1757,1757,1,2200,2207,5,2434,2435,7,2631,2632,5,2817,2817,5,3008,3008,5,3201,3201,5,3387,3388,5,3542,3542,5,3902,3903,7,4190,4192,5,6002,6003,5,6439,6440,5,6765,6770,7,7019,7027,5,7154,7155,7,8205,8205,13,8505,8505,14,9654,9654,14,9757,9757,14,9792,9792,14,9852,9853,14,9890,9894,14,9937,9937,14,9981,9981,14,10035,10036,14,11035,11036,14,42654,42655,5,43346,43347,7,43587,43587,5,44006,44007,7,44173,44199,12,44397,44423,12,44621,44647,12,44845,44871,12,45069,45095,12,45293,45319,12,45517,45543,12,45741,45767,12,45965,45991,12,46189,46215,12,46413,46439,12,46637,46663,12,46861,46887,12,47085,47111,12,47309,47335,12,47533,47559,12,47757,47783,12,47981,48007,12,48205,48231,12,48429,48455,12,48653,48679,12,48877,48903,12,49101,49127,12,49325,49351,12,49549,49575,12,49773,49799,12,49997,50023,12,50221,50247,12,50445,50471,12,50669,50695,12,50893,50919,12,51117,51143,12,51341,51367,12,51565,51591,12,51789,51815,12,52013,52039,12,52237,52263,12,52461,52487,12,52685,52711,12,52909,52935,12,53133,53159,12,53357,53383,12,53581,53607,12,53805,53831,12,54029,54055,12,54253,54279,12,54477,54503,12,54701,54727,12,54925,54951,12,55149,55175,12,68101,68102,5,69762,69762,7,70067,70069,7,70371,70378,5,70720,70721,7,71087,71087,5,71341,71341,5,71995,71996,5,72249,72249,7,72850,72871,5,73109,73109,5,118576,118598,5,121505,121519,5,127245,127247,14,127568,127569,14,127777,127777,14,127872,127891,14,127956,127967,14,128015,128016,14,128110,128172,14,128259,128259,14,128367,128368,14,128424,128424,14,128488,128488,14,128530,128532,14,128550,128551,14,128566,128566,14,128647,128647,14,128656,128656,14,128667,128673,14,128691,128693,14,128715,128715,14,128728,128732,14,128752,128752,14,128765,128767,14,129096,129103,14,129311,129311,14,129344,129349,14,129394,129394,14,129413,129425,14,129466,129471,14,129511,129535,14,129664,129666,14,129719,129722,14,129760,129767,14,917536,917631,5,13,13,2,1160,1161,5,1564,1564,4,1807,1807,1,2085,2087,5,2307,2307,7,2382,2383,7,2497,2500,5,2563,2563,7,2677,2677,5,2763,2764,7,2879,2879,5,2914,2915,5,3021,3021,5,3142,3144,5,3263,3263,5,3285,3286,5,3398,3400,7,3530,3530,5,3633,3633,5,3864,3865,5,3974,3975,5,4155,4156,7,4229,4230,5,5909,5909,7,6078,6085,7,6277,6278,5,6451,6456,7,6744,6750,5,6846,6846,5,6972,6972,5,7074,7077,5,7146,7148,7,7222,7223,5,7416,7417,5,8234,8238,4,8417,8417,5,9000,9000,14,9203,9203,14,9730,9731,14,9748,9749,14,9762,9763,14,9776,9783,14,9800,9811,14,9831,9831,14,9872,9873,14,9882,9882,14,9900,9903,14,9929,9933,14,9941,9960,14,9974,9974,14,9989,9989,14,10006,10006,14,10062,10062,14,10160,10160,14,11647,11647,5,12953,12953,14,43019,43019,5,43232,43249,5,43443,43443,5,43567,43568,7,43696,43696,5,43765,43765,7,44013,44013,5,44117,44143,12,44229,44255,12,44341,44367,12,44453,44479,12,44565,44591,12,44677,44703,12,44789,44815,12,44901,44927,12,45013,45039,12,45125,45151,12,45237,45263,12,45349,45375,12,45461,45487,12,45573,45599,12,45685,45711,12,45797,45823,12,45909,45935,12,46021,46047,12,46133,46159,12,46245,46271,12,46357,46383,12,46469,46495,12,46581,46607,12,46693,46719,12,46805,46831,12,46917,46943,12,47029,47055,12,47141,47167,12,47253,47279,12,47365,47391,12,47477,47503,12,47589,47615,12,47701,47727,12,47813,47839,12,47925,47951,12,48037,48063,12,48149,48175,12,48261,48287,12,48373,48399,12,48485,48511,12,48597,48623,12,48709,48735,12,48821,48847,12,48933,48959,12,49045,49071,12,49157,49183,12,49269,49295,12,49381,49407,12,49493,49519,12,49605,49631,12,49717,49743,12,49829,49855,12,49941,49967,12,50053,50079,12,50165,50191,12,50277,50303,12,50389,50415,12,50501,50527,12,50613,50639,12,50725,50751,12,50837,50863,12,50949,50975,12,51061,51087,12,51173,51199,12,51285,51311,12,51397,51423,12,51509,51535,12,51621,51647,12,51733,51759,12,51845,51871,12,51957,51983,12,52069,52095,12,52181,52207,12,52293,52319,12,52405,52431,12,52517,52543,12,52629,52655,12,52741,52767,12,52853,52879,12,52965,52991,12,53077,53103,12,53189,53215,12,53301,53327,12,53413,53439,12,53525,53551,12,53637,53663,12,53749,53775,12,53861,53887,12,53973,53999,12,54085,54111,12,54197,54223,12,54309,54335,12,54421,54447,12,54533,54559,12,54645,54671,12,54757,54783,12,54869,54895,12,54981,55007,12,55093,55119,12,55243,55291,10,66045,66045,5,68325,68326,5,69688,69702,5,69817,69818,5,69957,69958,7,70089,70092,5,70198,70199,5,70462,70462,5,70502,70508,5,70750,70750,5,70846,70846,7,71100,71101,5,71230,71230,7,71351,71351,5,71737,71738,5,72000,72000,7,72160,72160,5,72273,72278,5,72752,72758,5,72882,72883,5,73031,73031,5,73461,73462,7,94192,94193,7,119149,119149,7,121403,121452,5,122915,122916,5,126980,126980,14,127358,127359,14,127535,127535,14,127759,127759,14,127771,127771,14,127792,127793,14,127825,127867,14,127897,127899,14,127945,127945,14,127985,127986,14,128000,128007,14,128021,128021,14,128066,128100,14,128184,128235,14,128249,128252,14,128266,128276,14,128335,128335,14,128379,128390,14,128407,128419,14,128444,128444,14,128481,128481,14,128499,128499,14,128526,128526,14,128536,128536,14,128543,128543,14,128556,128556,14,128564,128564,14,128577,128580,14,128643,128645,14,128649,128649,14,128654,128654,14,128660,128660,14,128664,128664,14,128675,128675,14,128686,128689,14,128695,128696,14,128705,128709,14,128717,128719,14,128725,128725,14,128736,128741,14,128747,128748,14,128755,128755,14,128762,128762,14,128981,128991,14,129009,129023,14,129160,129167,14,129296,129304,14,129320,129327,14,129340,129342,14,129356,129356,14,129388,129392,14,129399,129400,14,129404,129407,14,129432,129442,14,129454,129455,14,129473,129474,14,129485,129487,14,129648,129651,14,129659,129660,14,129671,129679,14,129709,129711,14,129728,129730,14,129751,129753,14,129776,129782,14,917505,917505,4,917760,917999,5,10,10,3,127,159,4,768,879,5,1471,1471,5,1536,1541,1,1648,1648,5,1767,1768,5,1840,1866,5,2070,2073,5,2137,2139,5,2274,2274,1,2363,2363,7,2377,2380,7,2402,2403,5,2494,2494,5,2507,2508,7,2558,2558,5,2622,2624,7,2641,2641,5,2691,2691,7,2759,2760,5,2786,2787,5,2876,2876,5,2881,2884,5,2901,2902,5,3006,3006,5,3014,3016,7,3072,3072,5,3134,3136,5,3157,3158,5,3260,3260,5,3266,3266,5,3274,3275,7,3328,3329,5,3391,3392,7,3405,3405,5,3457,3457,5,3536,3537,7,3551,3551,5,3636,3642,5,3764,3772,5,3895,3895,5,3967,3967,7,3993,4028,5,4146,4151,5,4182,4183,7,4226,4226,5,4253,4253,5,4957,4959,5,5940,5940,7,6070,6070,7,6087,6088,7,6158,6158,4,6432,6434,5,6448,6449,7,6679,6680,5,6742,6742,5,6754,6754,5,6783,6783,5,6912,6915,5,6966,6970,5,6978,6978,5,7042,7042,7,7080,7081,5,7143,7143,7,7150,7150,7,7212,7219,5,7380,7392,5,7412,7412,5,8203,8203,4,8232,8232,4,8265,8265,14,8400,8412,5,8421,8432,5,8617,8618,14,9167,9167,14,9200,9200,14,9410,9410,14,9723,9726,14,9733,9733,14,9745,9745,14,9752,9752,14,9760,9760,14,9766,9766,14,9774,9774,14,9786,9786,14,9794,9794,14,9823,9823,14,9828,9828,14,9833,9850,14,9855,9855,14,9875,9875,14,9880,9880,14,9885,9887,14,9896,9897,14,9906,9916,14,9926,9927,14,9935,9935,14,9939,9939,14,9962,9962,14,9972,9972,14,9978,9978,14,9986,9986,14,9997,9997,14,10002,10002,14,10017,10017,14,10055,10055,14,10071,10071,14,10133,10135,14,10548,10549,14,11093,11093,14,12330,12333,5,12441,12442,5,42608,42610,5,43010,43010,5,43045,43046,5,43188,43203,7,43302,43309,5,43392,43394,5,43446,43449,5,43493,43493,5,43571,43572,7,43597,43597,7,43703,43704,5,43756,43757,5,44003,44004,7,44009,44010,7,44033,44059,12,44089,44115,12,44145,44171,12,44201,44227,12,44257,44283,12,44313,44339,12,44369,44395,12,44425,44451,12,44481,44507,12,44537,44563,12,44593,44619,12,44649,44675,12,44705,44731,12,44761,44787,12,44817,44843,12,44873,44899,12,44929,44955,12,44985,45011,12,45041,45067,12,45097,45123,12,45153,45179,12,45209,45235,12,45265,45291,12,45321,45347,12,45377,45403,12,45433,45459,12,45489,45515,12,45545,45571,12,45601,45627,12,45657,45683,12,45713,45739,12,45769,45795,12,45825,45851,12,45881,45907,12,45937,45963,12,45993,46019,12,46049,46075,12,46105,46131,12,46161,46187,12,46217,46243,12,46273,46299,12,46329,46355,12,46385,46411,12,46441,46467,12,46497,46523,12,46553,46579,12,46609,46635,12,46665,46691,12,46721,46747,12,46777,46803,12,46833,46859,12,46889,46915,12,46945,46971,12,47001,47027,12,47057,47083,12,47113,47139,12,47169,47195,12,47225,47251,12,47281,47307,12,47337,47363,12,47393,47419,12,47449,47475,12,47505,47531,12,47561,47587,12,47617,47643,12,47673,47699,12,47729,47755,12,47785,47811,12,47841,47867,12,47897,47923,12,47953,47979,12,48009,48035,12,48065,48091,12,48121,48147,12,48177,48203,12,48233,48259,12,48289,48315,12,48345,48371,12,48401,48427,12,48457,48483,12,48513,48539,12,48569,48595,12,48625,48651,12,48681,48707,12,48737,48763,12,48793,48819,12,48849,48875,12,48905,48931,12,48961,48987,12,49017,49043,12,49073,49099,12,49129,49155,12,49185,49211,12,49241,49267,12,49297,49323,12,49353,49379,12,49409,49435,12,49465,49491,12,49521,49547,12,49577,49603,12,49633,49659,12,49689,49715,12,49745,49771,12,49801,49827,12,49857,49883,12,49913,49939,12,49969,49995,12,50025,50051,12,50081,50107,12,50137,50163,12,50193,50219,12,50249,50275,12,50305,50331,12,50361,50387,12,50417,50443,12,50473,50499,12,50529,50555,12,50585,50611,12,50641,50667,12,50697,50723,12,50753,50779,12,50809,50835,12,50865,50891,12,50921,50947,12,50977,51003,12,51033,51059,12,51089,51115,12,51145,51171,12,51201,51227,12,51257,51283,12,51313,51339,12,51369,51395,12,51425,51451,12,51481,51507,12,51537,51563,12,51593,51619,12,51649,51675,12,51705,51731,12,51761,51787,12,51817,51843,12,51873,51899,12,51929,51955,12,51985,52011,12,52041,52067,12,52097,52123,12,52153,52179,12,52209,52235,12,52265,52291,12,52321,52347,12,52377,52403,12,52433,52459,12,52489,52515,12,52545,52571,12,52601,52627,12,52657,52683,12,52713,52739,12,52769,52795,12,52825,52851,12,52881,52907,12,52937,52963,12,52993,53019,12,53049,53075,12,53105,53131,12,53161,53187,12,53217,53243,12,53273,53299,12,53329,53355,12,53385,53411,12,53441,53467,12,53497,53523,12,53553,53579,12,53609,53635,12,53665,53691,12,53721,53747,12,53777,53803,12,53833,53859,12,53889,53915,12,53945,53971,12,54001,54027,12,54057,54083,12,54113,54139,12,54169,54195,12,54225,54251,12,54281,54307,12,54337,54363,12,54393,54419,12,54449,54475,12,54505,54531,12,54561,54587,12,54617,54643,12,54673,54699,12,54729,54755,12,54785,54811,12,54841,54867,12,54897,54923,12,54953,54979,12,55009,55035,12,55065,55091,12,55121,55147,12,55177,55203,12,65024,65039,5,65520,65528,4,66422,66426,5,68152,68154,5,69291,69292,5,69633,69633,5,69747,69748,5,69811,69814,5,69826,69826,5,69932,69932,7,70016,70017,5,70079,70080,7,70095,70095,5,70196,70196,5,70367,70367,5,70402,70403,7,70464,70464,5,70487,70487,5,70709,70711,7,70725,70725,7,70833,70834,7,70843,70844,7,70849,70849,7,71090,71093,5,71103,71104,5,71227,71228,7,71339,71339,5,71344,71349,5,71458,71461,5,71727,71735,5,71985,71989,7,71998,71998,5,72002,72002,7,72154,72155,5,72193,72202,5,72251,72254,5,72281,72283,5,72344,72345,5,72766,72766,7,72874,72880,5,72885,72886,5,73023,73029,5,73104,73105,5,73111,73111,5,92912,92916,5,94095,94098,5,113824,113827,4,119142,119142,7,119155,119162,4,119362,119364,5,121476,121476,5,122888,122904,5,123184,123190,5,125252,125258,5,127183,127183,14,127340,127343,14,127377,127386,14,127491,127503,14,127548,127551,14,127744,127756,14,127761,127761,14,127769,127769,14,127773,127774,14,127780,127788,14,127796,127797,14,127820,127823,14,127869,127869,14,127894,127895,14,127902,127903,14,127943,127943,14,127947,127950,14,127972,127972,14,127988,127988,14,127992,127994,14,128009,128011,14,128019,128019,14,128023,128041,14,128064,128064,14,128102,128107,14,128174,128181,14,128238,128238,14,128246,128247,14,128254,128254,14,128264,128264,14,128278,128299,14,128329,128330,14,128348,128359,14,128371,128377,14,128392,128393,14,128401,128404,14,128421,128421,14,128433,128434,14,128450,128452,14,128476,128478,14,128483,128483,14,128495,128495,14,128506,128506,14,128519,128520,14,128528,128528,14,128534,128534,14,128538,128538,14,128540,128542,14,128544,128549,14,128552,128555,14,128557,128557,14,128560,128563,14,128565,128565,14,128567,128576,14,128581,128591,14,128641,128642,14,128646,128646,14,128648,128648,14,128650,128651,14,128653,128653,14,128655,128655,14,128657,128659,14,128661,128661,14,128663,128663,14,128665,128666,14,128674,128674,14,128676,128677,14,128679,128685,14,128690,128690,14,128694,128694,14,128697,128702,14,128704,128704,14,128710,128714,14,128716,128716,14,128720,128720,14,128723,128724,14,128726,128727,14,128733,128735,14,128742,128744,14,128746,128746,14,128749,128751,14,128753,128754,14,128756,128758,14,128761,128761,14,128763,128764,14,128884,128895,14,128992,129003,14,129008,129008,14,129036,129039,14,129114,129119,14,129198,129279,14,129293,129295,14,129305,129310,14,129312,129319,14,129328,129328,14,129331,129338,14,129343,129343,14,129351,129355,14,129357,129359,14,129375,129387,14,129393,129393,14,129395,129398,14,129401,129401,14,129403,129403,14,129408,129412,14,129426,129431,14,129443,129444,14,129451,129453,14,129456,129465,14,129472,129472,14,129475,129482,14,129484,129484,14,129488,129510,14,129536,129647,14,129652,129652,14,129656,129658,14,129661,129663,14,129667,129670,14,129680,129685,14,129705,129708,14,129712,129718,14,129723,129727,14,129731,129733,14,129744,129750,14,129754,129759,14,129768,129775,14,129783,129791,14,917504,917504,4,917506,917535,4,917632,917759,4,918000,921599,4,0,9,4,11,12,4,14,31,4,169,169,14,174,174,14,1155,1159,5,1425,1469,5,1473,1474,5,1479,1479,5,1552,1562,5,1611,1631,5,1750,1756,5,1759,1764,5,1770,1773,5,1809,1809,5,1958,1968,5,2045,2045,5,2075,2083,5,2089,2093,5,2192,2193,1,2250,2273,5,2275,2306,5,2362,2362,5,2364,2364,5,2369,2376,5,2381,2381,5,2385,2391,5,2433,2433,5,2492,2492,5,2495,2496,7,2503,2504,7,2509,2509,5,2530,2531,5,2561,2562,5,2620,2620,5,2625,2626,5,2635,2637,5,2672,2673,5,2689,2690,5,2748,2748,5,2753,2757,5,2761,2761,7,2765,2765,5,2810,2815,5,2818,2819,7,2878,2878,5,2880,2880,7,2887,2888,7,2893,2893,5,2903,2903,5,2946,2946,5,3007,3007,7,3009,3010,7,3018,3020,7,3031,3031,5,3073,3075,7,3132,3132,5,3137,3140,7,3146,3149,5,3170,3171,5,3202,3203,7,3262,3262,7,3264,3265,7,3267,3268,7,3271,3272,7,3276,3277,5,3298,3299,5,3330,3331,7,3390,3390,5,3393,3396,5,3402,3404,7,3406,3406,1,3426,3427,5,3458,3459,7,3535,3535,5,3538,3540,5,3544,3550,7,3570,3571,7,3635,3635,7,3655,3662,5,3763,3763,7,3784,3789,5,3893,3893,5,3897,3897,5,3953,3966,5,3968,3972,5,3981,3991,5,4038,4038,5,4145,4145,7,4153,4154,5,4157,4158,5,4184,4185,5,4209,4212,5,4228,4228,7,4237,4237,5,4352,4447,8,4520,4607,10,5906,5908,5,5938,5939,5,5970,5971,5,6068,6069,5,6071,6077,5,6086,6086,5,6089,6099,5,6155,6157,5,6159,6159,5,6313,6313,5,6435,6438,7,6441,6443,7,6450,6450,5,6457,6459,5,6681,6682,7,6741,6741,7,6743,6743,7,6752,6752,5,6757,6764,5,6771,6780,5,6832,6845,5,6847,6862,5,6916,6916,7,6965,6965,5,6971,6971,7,6973,6977,7,6979,6980,7,7040,7041,5,7073,7073,7,7078,7079,7,7082,7082,7,7142,7142,5,7144,7145,5,7149,7149,5,7151,7153,5,7204,7211,7,7220,7221,7,7376,7378,5,7393,7393,7,7405,7405,5,7415,7415,7,7616,7679,5,8204,8204,5,8206,8207,4,8233,8233,4,8252,8252,14,8288,8292,4,8294,8303,4,8413,8416,5,8418,8420,5,8482,8482,14,8596,8601,14,8986,8987,14,9096,9096,14,9193,9196,14,9199,9199,14,9201,9202,14,9208,9210,14,9642,9643,14,9664,9664,14,9728,9729,14,9732,9732,14,9735,9741,14,9743,9744,14,9746,9746,14,9750,9751,14,9753,9756,14,9758,9759,14,9761,9761,14,9764,9765,14,9767,9769,14,9771,9773,14,9775,9775,14,9784,9785,14,9787,9791,14,9793,9793,14,9795,9799,14,9812,9822,14,9824,9824,14,9827,9827,14,9829,9830,14,9832,9832,14,9851,9851,14,9854,9854,14,9856,9861,14,9874,9874,14,9876,9876,14,9878,9879,14,9881,9881,14,9883,9884,14,9888,9889,14,9895,9895,14,9898,9899,14,9904,9905,14,9917,9918,14,9924,9925,14,9928,9928,14,9934,9934,14,9936,9936,14,9938,9938,14,9940,9940,14,9961,9961,14,9963,9967,14,9970,9971,14,9973,9973,14,9975,9977,14,9979,9980,14,9982,9985,14,9987,9988,14,9992,9996,14,9998,9998,14,10000,10001,14,10004,10004,14,10013,10013,14,10024,10024,14,10052,10052,14,10060,10060,14,10067,10069,14,10083,10083,14,10085,10087,14,10145,10145,14,10175,10175,14,11013,11015,14,11088,11088,14,11503,11505,5,11744,11775,5,12334,12335,5,12349,12349,14,12951,12951,14,42607,42607,5,42612,42621,5,42736,42737,5,43014,43014,5,43043,43044,7,43047,43047,7,43136,43137,7,43204,43205,5,43263,43263,5,43335,43345,5,43360,43388,8,43395,43395,7,43444,43445,7,43450,43451,7,43454,43456,7,43561,43566,5,43569,43570,5,43573,43574,5,43596,43596,5,43644,43644,5,43698,43700,5,43710,43711,5,43755,43755,7,43758,43759,7,43766,43766,5,44005,44005,5,44008,44008,5,44012,44012,7,44032,44032,11,44060,44060,11,44088,44088,11,44116,44116,11,44144,44144,11,44172,44172,11,44200,44200,11,44228,44228,11,44256,44256,11,44284,44284,11,44312,44312,11,44340,44340,11,44368,44368,11,44396,44396,11,44424,44424,11,44452,44452,11,44480,44480,11,44508,44508,11,44536,44536,11,44564,44564,11,44592,44592,11,44620,44620,11,44648,44648,11,44676,44676,11,44704,44704,11,44732,44732,11,44760,44760,11,44788,44788,11,44816,44816,11,44844,44844,11,44872,44872,11,44900,44900,11,44928,44928,11,44956,44956,11,44984,44984,11,45012,45012,11,45040,45040,11,45068,45068,11,45096,45096,11,45124,45124,11,45152,45152,11,45180,45180,11,45208,45208,11,45236,45236,11,45264,45264,11,45292,45292,11,45320,45320,11,45348,45348,11,45376,45376,11,45404,45404,11,45432,45432,11,45460,45460,11,45488,45488,11,45516,45516,11,45544,45544,11,45572,45572,11,45600,45600,11,45628,45628,11,45656,45656,11,45684,45684,11,45712,45712,11,45740,45740,11,45768,45768,11,45796,45796,11,45824,45824,11,45852,45852,11,45880,45880,11,45908,45908,11,45936,45936,11,45964,45964,11,45992,45992,11,46020,46020,11,46048,46048,11,46076,46076,11,46104,46104,11,46132,46132,11,46160,46160,11,46188,46188,11,46216,46216,11,46244,46244,11,46272,46272,11,46300,46300,11,46328,46328,11,46356,46356,11,46384,46384,11,46412,46412,11,46440,46440,11,46468,46468,11,46496,46496,11,46524,46524,11,46552,46552,11,46580,46580,11,46608,46608,11,46636,46636,11,46664,46664,11,46692,46692,11,46720,46720,11,46748,46748,11,46776,46776,11,46804,46804,11,46832,46832,11,46860,46860,11,46888,46888,11,46916,46916,11,46944,46944,11,46972,46972,11,47000,47000,11,47028,47028,11,47056,47056,11,47084,47084,11,47112,47112,11,47140,47140,11,47168,47168,11,47196,47196,11,47224,47224,11,47252,47252,11,47280,47280,11,47308,47308,11,47336,47336,11,47364,47364,11,47392,47392,11,47420,47420,11,47448,47448,11,47476,47476,11,47504,47504,11,47532,47532,11,47560,47560,11,47588,47588,11,47616,47616,11,47644,47644,11,47672,47672,11,47700,47700,11,47728,47728,11,47756,47756,11,47784,47784,11,47812,47812,11,47840,47840,11,47868,47868,11,47896,47896,11,47924,47924,11,47952,47952,11,47980,47980,11,48008,48008,11,48036,48036,11,48064,48064,11,48092,48092,11,48120,48120,11,48148,48148,11,48176,48176,11,48204,48204,11,48232,48232,11,48260,48260,11,48288,48288,11,48316,48316,11,48344,48344,11,48372,48372,11,48400,48400,11,48428,48428,11,48456,48456,11,48484,48484,11,48512,48512,11,48540,48540,11,48568,48568,11,48596,48596,11,48624,48624,11,48652,48652,11,48680,48680,11,48708,48708,11,48736,48736,11,48764,48764,11,48792,48792,11,48820,48820,11,48848,48848,11,48876,48876,11,48904,48904,11,48932,48932,11,48960,48960,11,48988,48988,11,49016,49016,11,49044,49044,11,49072,49072,11,49100,49100,11,49128,49128,11,49156,49156,11,49184,49184,11,49212,49212,11,49240,49240,11,49268,49268,11,49296,49296,11,49324,49324,11,49352,49352,11,49380,49380,11,49408,49408,11,49436,49436,11,49464,49464,11,49492,49492,11,49520,49520,11,49548,49548,11,49576,49576,11,49604,49604,11,49632,49632,11,49660,49660,11,49688,49688,11,49716,49716,11,49744,49744,11,49772,49772,11,49800,49800,11,49828,49828,11,49856,49856,11,49884,49884,11,49912,49912,11,49940,49940,11,49968,49968,11,49996,49996,11,50024,50024,11,50052,50052,11,50080,50080,11,50108,50108,11,50136,50136,11,50164,50164,11,50192,50192,11,50220,50220,11,50248,50248,11,50276,50276,11,50304,50304,11,50332,50332,11,50360,50360,11,50388,50388,11,50416,50416,11,50444,50444,11,50472,50472,11,50500,50500,11,50528,50528,11,50556,50556,11,50584,50584,11,50612,50612,11,50640,50640,11,50668,50668,11,50696,50696,11,50724,50724,11,50752,50752,11,50780,50780,11,50808,50808,11,50836,50836,11,50864,50864,11,50892,50892,11,50920,50920,11,50948,50948,11,50976,50976,11,51004,51004,11,51032,51032,11,51060,51060,11,51088,51088,11,51116,51116,11,51144,51144,11,51172,51172,11,51200,51200,11,51228,51228,11,51256,51256,11,51284,51284,11,51312,51312,11,51340,51340,11,51368,51368,11,51396,51396,11,51424,51424,11,51452,51452,11,51480,51480,11,51508,51508,11,51536,51536,11,51564,51564,11,51592,51592,11,51620,51620,11,51648,51648,11,51676,51676,11,51704,51704,11,51732,51732,11,51760,51760,11,51788,51788,11,51816,51816,11,51844,51844,11,51872,51872,11,51900,51900,11,51928,51928,11,51956,51956,11,51984,51984,11,52012,52012,11,52040,52040,11,52068,52068,11,52096,52096,11,52124,52124,11,52152,52152,11,52180,52180,11,52208,52208,11,52236,52236,11,52264,52264,11,52292,52292,11,52320,52320,11,52348,52348,11,52376,52376,11,52404,52404,11,52432,52432,11,52460,52460,11,52488,52488,11,52516,52516,11,52544,52544,11,52572,52572,11,52600,52600,11,52628,52628,11,52656,52656,11,52684,52684,11,52712,52712,11,52740,52740,11,52768,52768,11,52796,52796,11,52824,52824,11,52852,52852,11,52880,52880,11,52908,52908,11,52936,52936,11,52964,52964,11,52992,52992,11,53020,53020,11,53048,53048,11,53076,53076,11,53104,53104,11,53132,53132,11,53160,53160,11,53188,53188,11,53216,53216,11,53244,53244,11,53272,53272,11,53300,53300,11,53328,53328,11,53356,53356,11,53384,53384,11,53412,53412,11,53440,53440,11,53468,53468,11,53496,53496,11,53524,53524,11,53552,53552,11,53580,53580,11,53608,53608,11,53636,53636,11,53664,53664,11,53692,53692,11,53720,53720,11,53748,53748,11,53776,53776,11,53804,53804,11,53832,53832,11,53860,53860,11,53888,53888,11,53916,53916,11,53944,53944,11,53972,53972,11,54000,54000,11,54028,54028,11,54056,54056,11,54084,54084,11,54112,54112,11,54140,54140,11,54168,54168,11,54196,54196,11,54224,54224,11,54252,54252,11,54280,54280,11,54308,54308,11,54336,54336,11,54364,54364,11,54392,54392,11,54420,54420,11,54448,54448,11,54476,54476,11,54504,54504,11,54532,54532,11,54560,54560,11,54588,54588,11,54616,54616,11,54644,54644,11,54672,54672,11,54700,54700,11,54728,54728,11,54756,54756,11,54784,54784,11,54812,54812,11,54840,54840,11,54868,54868,11,54896,54896,11,54924,54924,11,54952,54952,11,54980,54980,11,55008,55008,11,55036,55036,11,55064,55064,11,55092,55092,11,55120,55120,11,55148,55148,11,55176,55176,11,55216,55238,9,64286,64286,5,65056,65071,5,65438,65439,5,65529,65531,4,66272,66272,5,68097,68099,5,68108,68111,5,68159,68159,5,68900,68903,5,69446,69456,5,69632,69632,7,69634,69634,7,69744,69744,5,69759,69761,5,69808,69810,7,69815,69816,7,69821,69821,1,69837,69837,1,69927,69931,5,69933,69940,5,70003,70003,5,70018,70018,7,70070,70078,5,70082,70083,1,70094,70094,7,70188,70190,7,70194,70195,7,70197,70197,7,70206,70206,5,70368,70370,7,70400,70401,5,70459,70460,5,70463,70463,7,70465,70468,7,70475,70477,7,70498,70499,7,70512,70516,5,70712,70719,5,70722,70724,5,70726,70726,5,70832,70832,5,70835,70840,5,70842,70842,5,70845,70845,5,70847,70848,5,70850,70851,5,71088,71089,7,71096,71099,7,71102,71102,7,71132,71133,5,71219,71226,5,71229,71229,5,71231,71232,5,71340,71340,7,71342,71343,7,71350,71350,7,71453,71455,5,71462,71462,7,71724,71726,7,71736,71736,7,71984,71984,5,71991,71992,7,71997,71997,7,71999,71999,1,72001,72001,1,72003,72003,5,72148,72151,5,72156,72159,7,72164,72164,7,72243,72248,5,72250,72250,1,72263,72263,5,72279,72280,7,72324,72329,1,72343,72343,7,72751,72751,7,72760,72765,5,72767,72767,5,72873,72873,7,72881,72881,7,72884,72884,7,73009,73014,5,73020,73021,5,73030,73030,1,73098,73102,7,73107,73108,7,73110,73110,7,73459,73460,5,78896,78904,4,92976,92982,5,94033,94087,7,94180,94180,5,113821,113822,5,118528,118573,5,119141,119141,5,119143,119145,5,119150,119154,5,119163,119170,5,119210,119213,5,121344,121398,5,121461,121461,5,121499,121503,5,122880,122886,5,122907,122913,5,122918,122922,5,123566,123566,5,125136,125142,5,126976,126979,14,126981,127182,14,127184,127231,14,127279,127279,14,127344,127345,14,127374,127374,14,127405,127461,14,127489,127490,14,127514,127514,14,127538,127546,14,127561,127567,14,127570,127743,14,127757,127758,14,127760,127760,14,127762,127762,14,127766,127768,14,127770,127770,14,127772,127772,14,127775,127776,14,127778,127779,14,127789,127791,14,127794,127795,14,127798,127798,14,127819,127819,14,127824,127824,14,127868,127868,14,127870,127871,14,127892,127893,14,127896,127896,14,127900,127901,14,127904,127940,14,127942,127942,14,127944,127944,14,127946,127946,14,127951,127955,14,127968,127971,14,127973,127984,14,127987,127987,14,127989,127989,14,127991,127991,14,127995,127999,5,128008,128008,14,128012,128014,14,128017,128018,14,128020,128020,14,128022,128022,14,128042,128042,14,128063,128063,14,128065,128065,14,128101,128101,14,128108,128109,14,128173,128173,14,128182,128183,14,128236,128237,14,128239,128239,14,128245,128245,14,128248,128248,14,128253,128253,14,128255,128258,14,128260,128263,14,128265,128265,14,128277,128277,14,128300,128301,14,128326,128328,14,128331,128334,14,128336,128347,14,128360,128366,14,128369,128370,14,128378,128378,14,128391,128391,14,128394,128397,14,128400,128400,14,128405,128406,14,128420,128420,14,128422,128423,14,128425,128432,14,128435,128443,14,128445,128449,14,128453,128464,14,128468,128475,14,128479,128480,14,128482,128482,14,128484,128487,14,128489,128494,14,128496,128498,14,128500,128505,14,128507,128511,14,128513,128518,14,128521,128525,14,128527,128527,14,128529,128529,14,128533,128533,14,128535,128535,14,128537,128537,14]');\n}\n//#endregion\n/**\n * Computes the offset after performing a left delete on the given string,\n * while considering unicode grapheme/emoji rules.\n*/\nexport function getLeftDeleteOffset(offset, str) {\n    if (offset === 0) {\n        return 0;\n    }\n    // Try to delete emoji part.\n    const emojiOffset = getOffsetBeforeLastEmojiComponent(offset, str);\n    if (emojiOffset !== undefined) {\n        return emojiOffset;\n    }\n    // Otherwise, just skip a single code point.\n    const codePoint = getPrevCodePoint(str, offset);\n    offset -= getUTF16Length(codePoint);\n    return offset;\n}\nfunction getOffsetBeforeLastEmojiComponent(offset, str) {\n    // See https://www.unicode.org/reports/tr51/tr51-14.html#EBNF_and_Regex for the\n    // structure of emojis.\n    let codePoint = getPrevCodePoint(str, offset);\n    offset -= getUTF16Length(codePoint);\n    // Skip modifiers\n    while ((isEmojiModifier(codePoint) || codePoint === 65039 /* emojiVariantSelector */ || codePoint === 8419 /* enclosingKeyCap */)) {\n        if (offset === 0) {\n            // Cannot skip modifier, no preceding emoji base.\n            return undefined;\n        }\n        codePoint = getPrevCodePoint(str, offset);\n        offset -= getUTF16Length(codePoint);\n    }\n    // Expect base emoji\n    if (!isEmojiImprecise(codePoint)) {\n        // Unexpected code point, not a valid emoji.\n        return undefined;\n    }\n    if (offset >= 0) {\n        // Skip optional ZWJ code points that combine multiple emojis.\n        // In theory, we should check if that ZWJ actually combines multiple emojis\n        // to prevent deleting ZWJs in situations we didn't account for.\n        const optionalZwjCodePoint = getPrevCodePoint(str, offset);\n        if (optionalZwjCodePoint === 8205 /* zwj */) {\n            offset -= getUTF16Length(optionalZwjCodePoint);\n        }\n    }\n    return offset;\n}\nfunction getUTF16Length(codePoint) {\n    return codePoint >= 65536 /* UNICODE_SUPPLEMENTARY_PLANE_BEGIN */ ? 2 : 1;\n}\nfunction isEmojiModifier(codePoint) {\n    return 0x1F3FB <= codePoint && codePoint <= 0x1F3FF;\n}\nexport const noBreakWhitespace = '\\xa0';\nexport class AmbiguousCharacters {\n    static getData() {\n        // Stored as key1, value1, key2, value2, ...\n        return JSON.parse('{\\\"_common\\\":[8232,32,8233,32,5760,32,8192,32,8193,32,8194,32,8195,32,8196,32,8197,32,8198,32,8200,32,8201,32,8202,32,8287,32,8199,32,8239,32,2042,95,65101,95,65102,95,65103,95,8208,45,8209,45,8210,45,65112,45,1748,45,8259,45,727,45,8722,45,10134,45,11450,45,1549,44,1643,44,8218,44,184,44,42233,44,894,59,2307,58,2691,58,1417,58,1795,58,1796,58,5868,58,65072,58,6147,58,6153,58,8282,58,1475,58,760,58,42889,58,8758,58,720,58,42237,58,451,33,11601,33,660,63,577,63,2429,63,5038,63,42731,63,119149,46,8228,46,1793,46,1794,46,42510,46,68176,46,1632,46,1776,46,42232,46,1373,96,65287,96,8219,96,8242,96,1370,96,1523,96,8175,96,65344,96,900,96,8189,96,8125,96,8127,96,8190,96,697,96,884,96,712,96,714,96,715,96,756,96,699,96,701,96,700,96,702,96,42892,96,1497,96,2036,96,2037,96,5194,96,5836,96,94033,96,94034,96,65339,40,10088,40,10098,40,12308,40,64830,40,65341,41,10089,41,10099,41,12309,41,64831,41,10100,123,119060,123,10101,125,8270,42,1645,42,8727,42,66335,42,5941,47,8257,47,8725,47,8260,47,9585,47,10187,47,10744,47,119354,47,12755,47,12339,47,11462,47,20031,47,12035,47,65340,92,65128,92,8726,92,10189,92,10741,92,10745,92,119311,92,119355,92,12756,92,20022,92,12034,92,42872,38,708,94,710,94,5869,43,10133,43,66203,43,8249,60,10094,60,706,60,119350,60,5176,60,5810,60,5120,61,11840,61,12448,61,42239,61,8250,62,10095,62,707,62,119351,62,5171,62,94015,62,8275,126,732,126,8128,126,8764,126,120784,50,120794,50,120804,50,120814,50,120824,50,130034,50,42842,50,423,50,1000,50,42564,50,5311,50,42735,50,119302,51,120785,51,120795,51,120805,51,120815,51,120825,51,130035,51,42923,51,540,51,439,51,42858,51,11468,51,1248,51,94011,51,71882,51,120786,52,120796,52,120806,52,120816,52,120826,52,130036,52,5070,52,71855,52,120787,53,120797,53,120807,53,120817,53,120827,53,130037,53,444,53,71867,53,120788,54,120798,54,120808,54,120818,54,120828,54,130038,54,11474,54,5102,54,71893,54,119314,55,120789,55,120799,55,120809,55,120819,55,120829,55,130039,55,66770,55,71878,55,2819,56,2538,56,2666,56,125131,56,120790,56,120800,56,120810,56,120820,56,120830,56,130040,56,547,56,546,56,66330,56,2663,57,2920,57,2541,57,3437,57,120791,57,120801,57,120811,57,120821,57,120831,57,130041,57,42862,57,11466,57,71884,57,71852,57,71894,57,9082,97,65345,97,119834,97,119886,97,119938,97,119990,97,120042,97,120094,97,120146,97,120198,97,120250,97,120302,97,120354,97,120406,97,120458,97,593,97,945,97,120514,97,120572,97,120630,97,120688,97,120746,97,65313,65,119808,65,119860,65,119912,65,119964,65,120016,65,120068,65,120120,65,120172,65,120224,65,120276,65,120328,65,120380,65,120432,65,913,65,120488,65,120546,65,120604,65,120662,65,120720,65,5034,65,5573,65,42222,65,94016,65,66208,65,119835,98,119887,98,119939,98,119991,98,120043,98,120095,98,120147,98,120199,98,120251,98,120303,98,120355,98,120407,98,120459,98,388,98,5071,98,5234,98,5551,98,65314,66,8492,66,119809,66,119861,66,119913,66,120017,66,120069,66,120121,66,120173,66,120225,66,120277,66,120329,66,120381,66,120433,66,42932,66,914,66,120489,66,120547,66,120605,66,120663,66,120721,66,5108,66,5623,66,42192,66,66178,66,66209,66,66305,66,65347,99,8573,99,119836,99,119888,99,119940,99,119992,99,120044,99,120096,99,120148,99,120200,99,120252,99,120304,99,120356,99,120408,99,120460,99,7428,99,1010,99,11429,99,43951,99,66621,99,128844,67,71922,67,71913,67,65315,67,8557,67,8450,67,8493,67,119810,67,119862,67,119914,67,119966,67,120018,67,120174,67,120226,67,120278,67,120330,67,120382,67,120434,67,1017,67,11428,67,5087,67,42202,67,66210,67,66306,67,66581,67,66844,67,8574,100,8518,100,119837,100,119889,100,119941,100,119993,100,120045,100,120097,100,120149,100,120201,100,120253,100,120305,100,120357,100,120409,100,120461,100,1281,100,5095,100,5231,100,42194,100,8558,68,8517,68,119811,68,119863,68,119915,68,119967,68,120019,68,120071,68,120123,68,120175,68,120227,68,120279,68,120331,68,120383,68,120435,68,5024,68,5598,68,5610,68,42195,68,8494,101,65349,101,8495,101,8519,101,119838,101,119890,101,119942,101,120046,101,120098,101,120150,101,120202,101,120254,101,120306,101,120358,101,120410,101,120462,101,43826,101,1213,101,8959,69,65317,69,8496,69,119812,69,119864,69,119916,69,120020,69,120072,69,120124,69,120176,69,120228,69,120280,69,120332,69,120384,69,120436,69,917,69,120492,69,120550,69,120608,69,120666,69,120724,69,11577,69,5036,69,42224,69,71846,69,71854,69,66182,69,119839,102,119891,102,119943,102,119995,102,120047,102,120099,102,120151,102,120203,102,120255,102,120307,102,120359,102,120411,102,120463,102,43829,102,42905,102,383,102,7837,102,1412,102,119315,70,8497,70,119813,70,119865,70,119917,70,120021,70,120073,70,120125,70,120177,70,120229,70,120281,70,120333,70,120385,70,120437,70,42904,70,988,70,120778,70,5556,70,42205,70,71874,70,71842,70,66183,70,66213,70,66853,70,65351,103,8458,103,119840,103,119892,103,119944,103,120048,103,120100,103,120152,103,120204,103,120256,103,120308,103,120360,103,120412,103,120464,103,609,103,7555,103,397,103,1409,103,119814,71,119866,71,119918,71,119970,71,120022,71,120074,71,120126,71,120178,71,120230,71,120282,71,120334,71,120386,71,120438,71,1292,71,5056,71,5107,71,42198,71,65352,104,8462,104,119841,104,119945,104,119997,104,120049,104,120101,104,120153,104,120205,104,120257,104,120309,104,120361,104,120413,104,120465,104,1211,104,1392,104,5058,104,65320,72,8459,72,8460,72,8461,72,119815,72,119867,72,119919,72,120023,72,120179,72,120231,72,120283,72,120335,72,120387,72,120439,72,919,72,120494,72,120552,72,120610,72,120668,72,120726,72,11406,72,5051,72,5500,72,42215,72,66255,72,731,105,9075,105,65353,105,8560,105,8505,105,8520,105,119842,105,119894,105,119946,105,119998,105,120050,105,120102,105,120154,105,120206,105,120258,105,120310,105,120362,105,120414,105,120466,105,120484,105,618,105,617,105,953,105,8126,105,890,105,120522,105,120580,105,120638,105,120696,105,120754,105,1110,105,42567,105,1231,105,43893,105,5029,105,71875,105,65354,106,8521,106,119843,106,119895,106,119947,106,119999,106,120051,106,120103,106,120155,106,120207,106,120259,106,120311,106,120363,106,120415,106,120467,106,1011,106,1112,106,65322,74,119817,74,119869,74,119921,74,119973,74,120025,74,120077,74,120129,74,120181,74,120233,74,120285,74,120337,74,120389,74,120441,74,42930,74,895,74,1032,74,5035,74,5261,74,42201,74,119844,107,119896,107,119948,107,120000,107,120052,107,120104,107,120156,107,120208,107,120260,107,120312,107,120364,107,120416,107,120468,107,8490,75,65323,75,119818,75,119870,75,119922,75,119974,75,120026,75,120078,75,120130,75,120182,75,120234,75,120286,75,120338,75,120390,75,120442,75,922,75,120497,75,120555,75,120613,75,120671,75,120729,75,11412,75,5094,75,5845,75,42199,75,66840,75,1472,124,8739,124,9213,124,65512,124,1633,124,1777,124,66336,124,125127,124,120783,124,120793,124,120803,124,120813,124,120823,124,130033,124,65321,124,8544,124,8464,124,8465,124,119816,124,119868,124,119920,124,120024,124,120128,124,120180,124,120232,124,120284,124,120336,124,120388,124,120440,124,406,124,65356,124,8572,124,8467,124,119845,124,119897,124,119949,124,120001,124,120053,124,120105,124,120157,124,120209,124,120261,124,120313,124,120365,124,120417,124,120469,124,448,124,120496,124,120554,124,120612,124,120670,124,120728,124,11410,124,1030,124,1216,124,1493,124,1503,124,1575,124,126464,124,126592,124,65166,124,65165,124,1994,124,11599,124,5825,124,42226,124,93992,124,66186,124,66313,124,119338,76,8556,76,8466,76,119819,76,119871,76,119923,76,120027,76,120079,76,120131,76,120183,76,120235,76,120287,76,120339,76,120391,76,120443,76,11472,76,5086,76,5290,76,42209,76,93974,76,71843,76,71858,76,66587,76,66854,76,65325,77,8559,77,8499,77,119820,77,119872,77,119924,77,120028,77,120080,77,120132,77,120184,77,120236,77,120288,77,120340,77,120392,77,120444,77,924,77,120499,77,120557,77,120615,77,120673,77,120731,77,1018,77,11416,77,5047,77,5616,77,5846,77,42207,77,66224,77,66321,77,119847,110,119899,110,119951,110,120003,110,120055,110,120107,110,120159,110,120211,110,120263,110,120315,110,120367,110,120419,110,120471,110,1400,110,1404,110,65326,78,8469,78,119821,78,119873,78,119925,78,119977,78,120029,78,120081,78,120185,78,120237,78,120289,78,120341,78,120393,78,120445,78,925,78,120500,78,120558,78,120616,78,120674,78,120732,78,11418,78,42208,78,66835,78,3074,111,3202,111,3330,111,3458,111,2406,111,2662,111,2790,111,3046,111,3174,111,3302,111,3430,111,3664,111,3792,111,4160,111,1637,111,1781,111,65359,111,8500,111,119848,111,119900,111,119952,111,120056,111,120108,111,120160,111,120212,111,120264,111,120316,111,120368,111,120420,111,120472,111,7439,111,7441,111,43837,111,959,111,120528,111,120586,111,120644,111,120702,111,120760,111,963,111,120532,111,120590,111,120648,111,120706,111,120764,111,11423,111,4351,111,1413,111,1505,111,1607,111,126500,111,126564,111,126596,111,65259,111,65260,111,65258,111,65257,111,1726,111,64428,111,64429,111,64427,111,64426,111,1729,111,64424,111,64425,111,64423,111,64422,111,1749,111,3360,111,4125,111,66794,111,71880,111,71895,111,66604,111,1984,79,2534,79,2918,79,12295,79,70864,79,71904,79,120782,79,120792,79,120802,79,120812,79,120822,79,130032,79,65327,79,119822,79,119874,79,119926,79,119978,79,120030,79,120082,79,120134,79,120186,79,120238,79,120290,79,120342,79,120394,79,120446,79,927,79,120502,79,120560,79,120618,79,120676,79,120734,79,11422,79,1365,79,11604,79,4816,79,2848,79,66754,79,42227,79,71861,79,66194,79,66219,79,66564,79,66838,79,9076,112,65360,112,119849,112,119901,112,119953,112,120005,112,120057,112,120109,112,120161,112,120213,112,120265,112,120317,112,120369,112,120421,112,120473,112,961,112,120530,112,120544,112,120588,112,120602,112,120646,112,120660,112,120704,112,120718,112,120762,112,120776,112,11427,112,65328,80,8473,80,119823,80,119875,80,119927,80,119979,80,120031,80,120083,80,120187,80,120239,80,120291,80,120343,80,120395,80,120447,80,929,80,120504,80,120562,80,120620,80,120678,80,120736,80,11426,80,5090,80,5229,80,42193,80,66197,80,119850,113,119902,113,119954,113,120006,113,120058,113,120110,113,120162,113,120214,113,120266,113,120318,113,120370,113,120422,113,120474,113,1307,113,1379,113,1382,113,8474,81,119824,81,119876,81,119928,81,119980,81,120032,81,120084,81,120188,81,120240,81,120292,81,120344,81,120396,81,120448,81,11605,81,119851,114,119903,114,119955,114,120007,114,120059,114,120111,114,120163,114,120215,114,120267,114,120319,114,120371,114,120423,114,120475,114,43847,114,43848,114,7462,114,11397,114,43905,114,119318,82,8475,82,8476,82,8477,82,119825,82,119877,82,119929,82,120033,82,120189,82,120241,82,120293,82,120345,82,120397,82,120449,82,422,82,5025,82,5074,82,66740,82,5511,82,42211,82,94005,82,65363,115,119852,115,119904,115,119956,115,120008,115,120060,115,120112,115,120164,115,120216,115,120268,115,120320,115,120372,115,120424,115,120476,115,42801,115,445,115,1109,115,43946,115,71873,115,66632,115,65331,83,119826,83,119878,83,119930,83,119982,83,120034,83,120086,83,120138,83,120190,83,120242,83,120294,83,120346,83,120398,83,120450,83,1029,83,1359,83,5077,83,5082,83,42210,83,94010,83,66198,83,66592,83,119853,116,119905,116,119957,116,120009,116,120061,116,120113,116,120165,116,120217,116,120269,116,120321,116,120373,116,120425,116,120477,116,8868,84,10201,84,128872,84,65332,84,119827,84,119879,84,119931,84,119983,84,120035,84,120087,84,120139,84,120191,84,120243,84,120295,84,120347,84,120399,84,120451,84,932,84,120507,84,120565,84,120623,84,120681,84,120739,84,11430,84,5026,84,42196,84,93962,84,71868,84,66199,84,66225,84,66325,84,119854,117,119906,117,119958,117,120010,117,120062,117,120114,117,120166,117,120218,117,120270,117,120322,117,120374,117,120426,117,120478,117,42911,117,7452,117,43854,117,43858,117,651,117,965,117,120534,117,120592,117,120650,117,120708,117,120766,117,1405,117,66806,117,71896,117,8746,85,8899,85,119828,85,119880,85,119932,85,119984,85,120036,85,120088,85,120140,85,120192,85,120244,85,120296,85,120348,85,120400,85,120452,85,1357,85,4608,85,66766,85,5196,85,42228,85,94018,85,71864,85,8744,118,8897,118,65366,118,8564,118,119855,118,119907,118,119959,118,120011,118,120063,118,120115,118,120167,118,120219,118,120271,118,120323,118,120375,118,120427,118,120479,118,7456,118,957,118,120526,118,120584,118,120642,118,120700,118,120758,118,1141,118,1496,118,71430,118,43945,118,71872,118,119309,86,1639,86,1783,86,8548,86,119829,86,119881,86,119933,86,119985,86,120037,86,120089,86,120141,86,120193,86,120245,86,120297,86,120349,86,120401,86,120453,86,1140,86,11576,86,5081,86,5167,86,42719,86,42214,86,93960,86,71840,86,66845,86,623,119,119856,119,119908,119,119960,119,120012,119,120064,119,120116,119,120168,119,120220,119,120272,119,120324,119,120376,119,120428,119,120480,119,7457,119,1121,119,1309,119,1377,119,71434,119,71438,119,71439,119,43907,119,71919,87,71910,87,119830,87,119882,87,119934,87,119986,87,120038,87,120090,87,120142,87,120194,87,120246,87,120298,87,120350,87,120402,87,120454,87,1308,87,5043,87,5076,87,42218,87,5742,120,10539,120,10540,120,10799,120,65368,120,8569,120,119857,120,119909,120,119961,120,120013,120,120065,120,120117,120,120169,120,120221,120,120273,120,120325,120,120377,120,120429,120,120481,120,5441,120,5501,120,5741,88,9587,88,66338,88,71916,88,65336,88,8553,88,119831,88,119883,88,119935,88,119987,88,120039,88,120091,88,120143,88,120195,88,120247,88,120299,88,120351,88,120403,88,120455,88,42931,88,935,88,120510,88,120568,88,120626,88,120684,88,120742,88,11436,88,11613,88,5815,88,42219,88,66192,88,66228,88,66327,88,66855,88,611,121,7564,121,65369,121,119858,121,119910,121,119962,121,120014,121,120066,121,120118,121,120170,121,120222,121,120274,121,120326,121,120378,121,120430,121,120482,121,655,121,7935,121,43866,121,947,121,8509,121,120516,121,120574,121,120632,121,120690,121,120748,121,1199,121,4327,121,71900,121,65337,89,119832,89,119884,89,119936,89,119988,89,120040,89,120092,89,120144,89,120196,89,120248,89,120300,89,120352,89,120404,89,120456,89,933,89,978,89,120508,89,120566,89,120624,89,120682,89,120740,89,11432,89,1198,89,5033,89,5053,89,42220,89,94019,89,71844,89,66226,89,119859,122,119911,122,119963,122,120015,122,120067,122,120119,122,120171,122,120223,122,120275,122,120327,122,120379,122,120431,122,120483,122,7458,122,43923,122,71876,122,66293,90,71909,90,65338,90,8484,90,8488,90,119833,90,119885,90,119937,90,119989,90,120041,90,120197,90,120249,90,120301,90,120353,90,120405,90,120457,90,918,90,120493,90,120551,90,120609,90,120667,90,120725,90,5059,90,42204,90,71849,90],\\\"_default\\\":[160,32,8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"cs\\\":[65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89],\\\"de\\\":[65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,1093,120,1061,88,1091,121,1059,89],\\\"es\\\":[8211,45,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"fr\\\":[65306,58,65281,33,8216,96,8245,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"it\\\":[160,32,8211,45,65306,58,65281,33,8216,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"ja\\\":[8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"ko\\\":[8211,45,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"pl\\\":[65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"pt-BR\\\":[65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"qps-ploc\\\":[160,32,8211,45,65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"ru\\\":[65306,58,65281,33,8216,96,8217,96,8245,96,180,96,12494,47,305,105,921,124,1009,112,215,120],\\\"tr\\\":[160,32,8211,45,65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"zh-hans\\\":[65306,58,65281,33,8245,96,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89],\\\"zh-hant\\\":[8211,45,180,96,12494,47,1047,51,1073,54,1072,97,1040,65,1068,98,1042,66,1089,99,1057,67,1077,101,1045,69,1053,72,305,105,1050,75,921,124,1052,77,1086,111,1054,79,1009,112,1088,112,1056,80,1075,114,1058,84,215,120,1093,120,1061,88,1091,121,1059,89]}');\n    }\n    static getConfusablesForCurrentLocale() {\n        if (!AmbiguousCharacters.map) {\n            const data = AmbiguousCharacters.getData();\n            let locale = platform.locale;\n            if (!locale || !(locale in data)) {\n                locale = platform.language;\n            }\n            if (!locale || !(locale in data)) {\n                locale = '_default';\n            }\n            function arrayToMap(arr) {\n                const result = new Map();\n                for (let i = 0; i < arr.length; i += 2) {\n                    result.set(arr[i], arr[i + 1]);\n                }\n                return result;\n            }\n            const set = arrayToMap(data['_common']);\n            const additionalConfusables = arrayToMap(data[locale]);\n            for (const [codePoint, originalCodePoint] of additionalConfusables) {\n                set.set(codePoint, originalCodePoint);\n            }\n            AmbiguousCharacters.map = set;\n        }\n        return AmbiguousCharacters.map;\n    }\n    static isAmbiguous(codePoint) {\n        return AmbiguousCharacters.getConfusablesForCurrentLocale().has(codePoint);\n    }\n    /**\n     * Returns the non basic ASCII code point that the given code point can be confused,\n     * or undefined if such code point does note exist.\n    */\n    static getPrimaryConfusable(codePoint) {\n        return AmbiguousCharacters.getConfusablesForCurrentLocale().get(codePoint);\n    }\n    static getPrimaryConfusableCodePoints() {\n        return new Set(AmbiguousCharacters.getConfusablesForCurrentLocale().keys());\n    }\n}\nexport class InvisibleCharacters {\n    static getRawData() {\n        return JSON.parse('[9,10,11,12,13,32,127,160,173,847,1564,4447,4448,6068,6069,6155,6156,6157,6158,7355,7356,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8203,8204,8205,8206,8207,8234,8235,8236,8237,8238,8239,8287,8288,8289,8290,8291,8292,8293,8294,8295,8296,8297,8298,8299,8300,8301,8302,8303,10240,12288,12644,65024,65025,65026,65027,65028,65029,65030,65031,65032,65033,65034,65035,65036,65037,65038,65039,65279,65440,65520,65521,65522,65523,65524,65525,65526,65527,65528,65532,78844,119155,119156,119157,119158,119159,119160,119161,119162,917504,917505,917506,917507,917508,917509,917510,917511,917512,917513,917514,917515,917516,917517,917518,917519,917520,917521,917522,917523,917524,917525,917526,917527,917528,917529,917530,917531,917532,917533,917534,917535,917536,917537,917538,917539,917540,917541,917542,917543,917544,917545,917546,917547,917548,917549,917550,917551,917552,917553,917554,917555,917556,917557,917558,917559,917560,917561,917562,917563,917564,917565,917566,917567,917568,917569,917570,917571,917572,917573,917574,917575,917576,917577,917578,917579,917580,917581,917582,917583,917584,917585,917586,917587,917588,917589,917590,917591,917592,917593,917594,917595,917596,917597,917598,917599,917600,917601,917602,917603,917604,917605,917606,917607,917608,917609,917610,917611,917612,917613,917614,917615,917616,917617,917618,917619,917620,917621,917622,917623,917624,917625,917626,917627,917628,917629,917630,917631,917760,917761,917762,917763,917764,917765,917766,917767,917768,917769,917770,917771,917772,917773,917774,917775,917776,917777,917778,917779,917780,917781,917782,917783,917784,917785,917786,917787,917788,917789,917790,917791,917792,917793,917794,917795,917796,917797,917798,917799,917800,917801,917802,917803,917804,917805,917806,917807,917808,917809,917810,917811,917812,917813,917814,917815,917816,917817,917818,917819,917820,917821,917822,917823,917824,917825,917826,917827,917828,917829,917830,917831,917832,917833,917834,917835,917836,917837,917838,917839,917840,917841,917842,917843,917844,917845,917846,917847,917848,917849,917850,917851,917852,917853,917854,917855,917856,917857,917858,917859,917860,917861,917862,917863,917864,917865,917866,917867,917868,917869,917870,917871,917872,917873,917874,917875,917876,917877,917878,917879,917880,917881,917882,917883,917884,917885,917886,917887,917888,917889,917890,917891,917892,917893,917894,917895,917896,917897,917898,917899,917900,917901,917902,917903,917904,917905,917906,917907,917908,917909,917910,917911,917912,917913,917914,917915,917916,917917,917918,917919,917920,917921,917922,917923,917924,917925,917926,917927,917928,917929,917930,917931,917932,917933,917934,917935,917936,917937,917938,917939,917940,917941,917942,917943,917944,917945,917946,917947,917948,917949,917950,917951,917952,917953,917954,917955,917956,917957,917958,917959,917960,917961,917962,917963,917964,917965,917966,917967,917968,917969,917970,917971,917972,917973,917974,917975,917976,917977,917978,917979,917980,917981,917982,917983,917984,917985,917986,917987,917988,917989,917990,917991,917992,917993,917994,917995,917996,917997,917998,917999]');\n    }\n    static getData() {\n        if (!this._data) {\n            this._data = new Set(InvisibleCharacters.getRawData());\n        }\n        return this._data;\n    }\n    static isInvisibleCharacter(codePoint) {\n        return InvisibleCharacters.getData().has(codePoint);\n    }\n    static get codePoints() {\n        return InvisibleCharacters.getData();\n    }\n}\nInvisibleCharacters._data = undefined;\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { transformErrorForSerialization } from '../errors.js';\nimport { Emitter } from '../event.js';\nimport { Disposable } from '../lifecycle.js';\nimport { globals, isWeb } from '../platform.js';\nimport * as types from '../types.js';\nimport * as strings from '../strings.js';\nconst INITIALIZE = '$initialize';\nlet webWorkerWarningLogged = false;\nexport function logOnceWebWorkerWarning(err) {\n    if (!isWeb) {\n        // running tests\n        return;\n    }\n    if (!webWorkerWarningLogged) {\n        webWorkerWarningLogged = true;\n        console.warn('Could not create web worker(s). Falling back to loading web worker code in main thread, which might cause UI freezes. Please see https://github.com/microsoft/monaco-editor#faq');\n    }\n    console.warn(err.message);\n}\nclass RequestMessage {\n    constructor(vsWorker, req, method, args) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.method = method;\n        this.args = args;\n        this.type = 0 /* Request */;\n    }\n}\nclass ReplyMessage {\n    constructor(vsWorker, seq, res, err) {\n        this.vsWorker = vsWorker;\n        this.seq = seq;\n        this.res = res;\n        this.err = err;\n        this.type = 1 /* Reply */;\n    }\n}\nclass SubscribeEventMessage {\n    constructor(vsWorker, req, eventName, arg) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.eventName = eventName;\n        this.arg = arg;\n        this.type = 2 /* SubscribeEvent */;\n    }\n}\nclass EventMessage {\n    constructor(vsWorker, req, event) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.event = event;\n        this.type = 3 /* Event */;\n    }\n}\nclass UnsubscribeEventMessage {\n    constructor(vsWorker, req) {\n        this.vsWorker = vsWorker;\n        this.req = req;\n        this.type = 4 /* UnsubscribeEvent */;\n    }\n}\nclass SimpleWorkerProtocol {\n    constructor(handler) {\n        this._workerId = -1;\n        this._handler = handler;\n        this._lastSentReq = 0;\n        this._pendingReplies = Object.create(null);\n        this._pendingEmitters = new Map();\n        this._pendingEvents = new Map();\n    }\n    setWorkerId(workerId) {\n        this._workerId = workerId;\n    }\n    sendMessage(method, args) {\n        const req = String(++this._lastSentReq);\n        return new Promise((resolve, reject) => {\n            this._pendingReplies[req] = {\n                resolve: resolve,\n                reject: reject\n            };\n            this._send(new RequestMessage(this._workerId, req, method, args));\n        });\n    }\n    listen(eventName, arg) {\n        let req = null;\n        const emitter = new Emitter({\n            onFirstListenerAdd: () => {\n                req = String(++this._lastSentReq);\n                this._pendingEmitters.set(req, emitter);\n                this._send(new SubscribeEventMessage(this._workerId, req, eventName, arg));\n            },\n            onLastListenerRemove: () => {\n                this._pendingEmitters.delete(req);\n                this._send(new UnsubscribeEventMessage(this._workerId, req));\n                req = null;\n            }\n        });\n        return emitter.event;\n    }\n    handleMessage(message) {\n        if (!message || !message.vsWorker) {\n            return;\n        }\n        if (this._workerId !== -1 && message.vsWorker !== this._workerId) {\n            return;\n        }\n        this._handleMessage(message);\n    }\n    _handleMessage(msg) {\n        switch (msg.type) {\n            case 1 /* Reply */:\n                return this._handleReplyMessage(msg);\n            case 0 /* Request */:\n                return this._handleRequestMessage(msg);\n            case 2 /* SubscribeEvent */:\n                return this._handleSubscribeEventMessage(msg);\n            case 3 /* Event */:\n                return this._handleEventMessage(msg);\n            case 4 /* UnsubscribeEvent */:\n                return this._handleUnsubscribeEventMessage(msg);\n        }\n    }\n    _handleReplyMessage(replyMessage) {\n        if (!this._pendingReplies[replyMessage.seq]) {\n            console.warn('Got reply to unknown seq');\n            return;\n        }\n        let reply = this._pendingReplies[replyMessage.seq];\n        delete this._pendingReplies[replyMessage.seq];\n        if (replyMessage.err) {\n            let err = replyMessage.err;\n            if (replyMessage.err.$isError) {\n                err = new Error();\n                err.name = replyMessage.err.name;\n                err.message = replyMessage.err.message;\n                err.stack = replyMessage.err.stack;\n            }\n            reply.reject(err);\n            return;\n        }\n        reply.resolve(replyMessage.res);\n    }\n    _handleRequestMessage(requestMessage) {\n        let req = requestMessage.req;\n        let result = this._handler.handleMessage(requestMessage.method, requestMessage.args);\n        result.then((r) => {\n            this._send(new ReplyMessage(this._workerId, req, r, undefined));\n        }, (e) => {\n            if (e.detail instanceof Error) {\n                // Loading errors have a detail property that points to the actual error\n                e.detail = transformErrorForSerialization(e.detail);\n            }\n            this._send(new ReplyMessage(this._workerId, req, undefined, transformErrorForSerialization(e)));\n        });\n    }\n    _handleSubscribeEventMessage(msg) {\n        const req = msg.req;\n        const disposable = this._handler.handleEvent(msg.eventName, msg.arg)((event) => {\n            this._send(new EventMessage(this._workerId, req, event));\n        });\n        this._pendingEvents.set(req, disposable);\n    }\n    _handleEventMessage(msg) {\n        if (!this._pendingEmitters.has(msg.req)) {\n            console.warn('Got event for unknown req');\n            return;\n        }\n        this._pendingEmitters.get(msg.req).fire(msg.event);\n    }\n    _handleUnsubscribeEventMessage(msg) {\n        if (!this._pendingEvents.has(msg.req)) {\n            console.warn('Got unsubscribe for unknown req');\n            return;\n        }\n        this._pendingEvents.get(msg.req).dispose();\n        this._pendingEvents.delete(msg.req);\n    }\n    _send(msg) {\n        let transfer = [];\n        if (msg.type === 0 /* Request */) {\n            for (let i = 0; i < msg.args.length; i++) {\n                if (msg.args[i] instanceof ArrayBuffer) {\n                    transfer.push(msg.args[i]);\n                }\n            }\n        }\n        else if (msg.type === 1 /* Reply */) {\n            if (msg.res instanceof ArrayBuffer) {\n                transfer.push(msg.res);\n            }\n        }\n        this._handler.sendMessage(msg, transfer);\n    }\n}\n/**\n * Main thread side\n */\nexport class SimpleWorkerClient extends Disposable {\n    constructor(workerFactory, moduleId, host) {\n        super();\n        let lazyProxyReject = null;\n        this._worker = this._register(workerFactory.create('vs/base/common/worker/simpleWorker', (msg) => {\n            this._protocol.handleMessage(msg);\n        }, (err) => {\n            // in Firefox, web workers fail lazily :(\n            // we will reject the proxy\n            if (lazyProxyReject) {\n                lazyProxyReject(err);\n            }\n        }));\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: (msg, transfer) => {\n                this._worker.postMessage(msg, transfer);\n            },\n            handleMessage: (method, args) => {\n                if (typeof host[method] !== 'function') {\n                    return Promise.reject(new Error('Missing method ' + method + ' on main thread host.'));\n                }\n                try {\n                    return Promise.resolve(host[method].apply(host, args));\n                }\n                catch (e) {\n                    return Promise.reject(e);\n                }\n            },\n            handleEvent: (eventName, arg) => {\n                if (propertyIsDynamicEvent(eventName)) {\n                    const event = host[eventName].call(host, arg);\n                    if (typeof event !== 'function') {\n                        throw new Error(`Missing dynamic event ${eventName} on main thread host.`);\n                    }\n                    return event;\n                }\n                if (propertyIsEvent(eventName)) {\n                    const event = host[eventName];\n                    if (typeof event !== 'function') {\n                        throw new Error(`Missing event ${eventName} on main thread host.`);\n                    }\n                    return event;\n                }\n                throw new Error(`Malformed event name ${eventName}`);\n            }\n        });\n        this._protocol.setWorkerId(this._worker.getId());\n        // Gather loader configuration\n        let loaderConfiguration = null;\n        if (typeof globals.require !== 'undefined' && typeof globals.require.getConfig === 'function') {\n            // Get the configuration from the Monaco AMD Loader\n            loaderConfiguration = globals.require.getConfig();\n        }\n        else if (typeof globals.requirejs !== 'undefined') {\n            // Get the configuration from requirejs\n            loaderConfiguration = globals.requirejs.s.contexts._.config;\n        }\n        const hostMethods = types.getAllMethodNames(host);\n        // Send initialize message\n        this._onModuleLoaded = this._protocol.sendMessage(INITIALIZE, [\n            this._worker.getId(),\n            JSON.parse(JSON.stringify(loaderConfiguration)),\n            moduleId,\n            hostMethods,\n        ]);\n        // Create proxy to loaded code\n        const proxyMethodRequest = (method, args) => {\n            return this._request(method, args);\n        };\n        const proxyListen = (eventName, arg) => {\n            return this._protocol.listen(eventName, arg);\n        };\n        this._lazyProxy = new Promise((resolve, reject) => {\n            lazyProxyReject = reject;\n            this._onModuleLoaded.then((availableMethods) => {\n                resolve(createProxyObject(availableMethods, proxyMethodRequest, proxyListen));\n            }, (e) => {\n                reject(e);\n                this._onError('Worker failed to load ' + moduleId, e);\n            });\n        });\n    }\n    getProxyObject() {\n        return this._lazyProxy;\n    }\n    _request(method, args) {\n        return new Promise((resolve, reject) => {\n            this._onModuleLoaded.then(() => {\n                this._protocol.sendMessage(method, args).then(resolve, reject);\n            }, reject);\n        });\n    }\n    _onError(message, error) {\n        console.error(message);\n        console.info(error);\n    }\n}\nfunction propertyIsEvent(name) {\n    // Assume a property is an event if it has a form of \"onSomething\"\n    return name[0] === 'o' && name[1] === 'n' && strings.isUpperAsciiLetter(name.charCodeAt(2));\n}\nfunction propertyIsDynamicEvent(name) {\n    // Assume a property is a dynamic event (a method that returns an event) if it has a form of \"onDynamicSomething\"\n    return /^onDynamic/.test(name) && strings.isUpperAsciiLetter(name.charCodeAt(9));\n}\nfunction createProxyObject(methodNames, invoke, proxyListen) {\n    const createProxyMethod = (method) => {\n        return function () {\n            const args = Array.prototype.slice.call(arguments, 0);\n            return invoke(method, args);\n        };\n    };\n    const createProxyDynamicEvent = (eventName) => {\n        return function (arg) {\n            return proxyListen(eventName, arg);\n        };\n    };\n    let result = {};\n    for (const methodName of methodNames) {\n        if (propertyIsDynamicEvent(methodName)) {\n            result[methodName] = createProxyDynamicEvent(methodName);\n            continue;\n        }\n        if (propertyIsEvent(methodName)) {\n            result[methodName] = proxyListen(methodName, undefined);\n            continue;\n        }\n        result[methodName] = createProxyMethod(methodName);\n    }\n    return result;\n}\n/**\n * Worker side\n */\nexport class SimpleWorkerServer {\n    constructor(postMessage, requestHandlerFactory) {\n        this._requestHandlerFactory = requestHandlerFactory;\n        this._requestHandler = null;\n        this._protocol = new SimpleWorkerProtocol({\n            sendMessage: (msg, transfer) => {\n                postMessage(msg, transfer);\n            },\n            handleMessage: (method, args) => this._handleMessage(method, args),\n            handleEvent: (eventName, arg) => this._handleEvent(eventName, arg)\n        });\n    }\n    onmessage(msg) {\n        this._protocol.handleMessage(msg);\n    }\n    _handleMessage(method, args) {\n        if (method === INITIALIZE) {\n            return this.initialize(args[0], args[1], args[2], args[3]);\n        }\n        if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._requestHandler[method].apply(this._requestHandler, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    }\n    _handleEvent(eventName, arg) {\n        if (!this._requestHandler) {\n            throw new Error(`Missing requestHandler`);\n        }\n        if (propertyIsDynamicEvent(eventName)) {\n            const event = this._requestHandler[eventName].call(this._requestHandler, arg);\n            if (typeof event !== 'function') {\n                throw new Error(`Missing dynamic event ${eventName} on request handler.`);\n            }\n            return event;\n        }\n        if (propertyIsEvent(eventName)) {\n            const event = this._requestHandler[eventName];\n            if (typeof event !== 'function') {\n                throw new Error(`Missing event ${eventName} on request handler.`);\n            }\n            return event;\n        }\n        throw new Error(`Malformed event name ${eventName}`);\n    }\n    initialize(workerId, loaderConfig, moduleId, hostMethods) {\n        this._protocol.setWorkerId(workerId);\n        const proxyMethodRequest = (method, args) => {\n            return this._protocol.sendMessage(method, args);\n        };\n        const proxyListen = (eventName, arg) => {\n            return this._protocol.listen(eventName, arg);\n        };\n        const hostProxy = createProxyObject(hostMethods, proxyMethodRequest, proxyListen);\n        if (this._requestHandlerFactory) {\n            // static request handler\n            this._requestHandler = this._requestHandlerFactory(hostProxy);\n            return Promise.resolve(types.getAllMethodNames(this._requestHandler));\n        }\n        if (loaderConfig) {\n            // Remove 'baseUrl', handling it is beyond scope for now\n            if (typeof loaderConfig.baseUrl !== 'undefined') {\n                delete loaderConfig['baseUrl'];\n            }\n            if (typeof loaderConfig.paths !== 'undefined') {\n                if (typeof loaderConfig.paths.vs !== 'undefined') {\n                    delete loaderConfig.paths['vs'];\n                }\n            }\n            if (typeof loaderConfig.trustedTypesPolicy !== undefined) {\n                // don't use, it has been destroyed during serialize\n                delete loaderConfig['trustedTypesPolicy'];\n            }\n            // Since this is in a web worker, enable catching errors\n            loaderConfig.catchError = true;\n            globals.require.config(loaderConfig);\n        }\n        return new Promise((resolve, reject) => {\n            // Use the global require to be sure to get the global config\n            // ESM-comment-begin\n            // \t\t\tconst req = (globals.require || require);\n            // ESM-comment-end\n            // ESM-uncomment-begin\n            const req = globals.require;\n            // ESM-uncomment-end\n            req([moduleId], (module) => {\n                this._requestHandler = module.create(hostProxy);\n                if (!this._requestHandler) {\n                    reject(new Error(`No RequestHandler!`));\n                    return;\n                }\n                resolve(types.getAllMethodNames(this._requestHandler));\n            }, reject);\n        });\n    }\n}\n/**\n * Called on the worker side\n */\nexport function create(postMessage) {\n    return new SimpleWorkerServer(postMessage, null);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { globals, isMacintosh, isWindows } from './platform.js';\nlet safeProcess;\n// Native sandbox environment\nif (typeof globals.vscode !== 'undefined' && typeof globals.vscode.process !== 'undefined') {\n    const sandboxProcess = globals.vscode.process;\n    safeProcess = {\n        get platform() { return sandboxProcess.platform; },\n        get arch() { return sandboxProcess.arch; },\n        get env() { return sandboxProcess.env; },\n        cwd() { return sandboxProcess.cwd(); }\n    };\n}\n// Native node.js environment\nelse if (typeof process !== 'undefined') {\n    safeProcess = {\n        get platform() { return process.platform; },\n        get arch() { return process.arch; },\n        get env() { return process.env; },\n        cwd() { return process.env['VSCODE_CWD'] || process.cwd(); }\n    };\n}\n// Web environment\nelse {\n    safeProcess = {\n        // Supported\n        get platform() { return isWindows ? 'win32' : isMacintosh ? 'darwin' : 'linux'; },\n        get arch() { return undefined; /* arch is undefined in web */ },\n        // Unsupported\n        get env() { return {}; },\n        cwd() { return '/'; }\n    };\n}\n/**\n * Provides safe access to the `cwd` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `/`.\n */\nexport const cwd = safeProcess.cwd;\n/**\n * Provides safe access to the `env` property in node.js, sandboxed or web\n * environments.\n *\n * Note: in web, this property is hardcoded to be `{}`.\n */\nexport const env = safeProcess.env;\n/**\n * Provides safe access to the `platform` property in node.js, sandboxed or web\n * environments.\n */\nexport const platform = safeProcess.platform;\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Represents information about a specific difference between two sequences.\n */\nexport class DiffChange {\n    /**\n     * Constructs a new DiffChange with the given sequence information\n     * and content.\n     */\n    constructor(originalStart, originalLength, modifiedStart, modifiedLength) {\n        //Debug.Assert(originalLength > 0 || modifiedLength > 0, \"originalLength and modifiedLength cannot both be <= 0\");\n        this.originalStart = originalStart;\n        this.originalLength = originalLength;\n        this.modifiedStart = modifiedStart;\n        this.modifiedLength = modifiedLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the original sequence.\n     */\n    getOriginalEnd() {\n        return this.originalStart + this.originalLength;\n    }\n    /**\n     * The end point (exclusive) of the change in the modified sequence.\n     */\n    getModifiedEnd() {\n        return this.modifiedStart + this.modifiedLength;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from './strings.js';\n/**\n * Return a hash value for an object.\n */\nexport function hash(obj) {\n    return doHash(obj, 0);\n}\nexport function doHash(obj, hashVal) {\n    switch (typeof obj) {\n        case 'object':\n            if (obj === null) {\n                return numberHash(349, hashVal);\n            }\n            else if (Array.isArray(obj)) {\n                return arrayHash(obj, hashVal);\n            }\n            return objectHash(obj, hashVal);\n        case 'string':\n            return stringHash(obj, hashVal);\n        case 'boolean':\n            return booleanHash(obj, hashVal);\n        case 'number':\n            return numberHash(obj, hashVal);\n        case 'undefined':\n            return numberHash(937, hashVal);\n        default:\n            return numberHash(617, hashVal);\n    }\n}\nexport function numberHash(val, initialHashVal) {\n    return (((initialHashVal << 5) - initialHashVal) + val) | 0; // hashVal * 31 + ch, keep as int32\n}\nfunction booleanHash(b, initialHashVal) {\n    return numberHash(b ? 433 : 863, initialHashVal);\n}\nexport function stringHash(s, hashVal) {\n    hashVal = numberHash(149417, hashVal);\n    for (let i = 0, length = s.length; i < length; i++) {\n        hashVal = numberHash(s.charCodeAt(i), hashVal);\n    }\n    return hashVal;\n}\nfunction arrayHash(arr, initialHashVal) {\n    initialHashVal = numberHash(104579, initialHashVal);\n    return arr.reduce((hashVal, item) => doHash(item, hashVal), initialHashVal);\n}\nfunction objectHash(obj, initialHashVal) {\n    initialHashVal = numberHash(181387, initialHashVal);\n    return Object.keys(obj).sort().reduce((hashVal, key) => {\n        hashVal = stringHash(key, hashVal);\n        return doHash(obj[key], hashVal);\n    }, initialHashVal);\n}\nfunction leftRotate(value, bits, totalBits = 32) {\n    // delta + bits = totalBits\n    const delta = totalBits - bits;\n    // All ones, expect `delta` zeros aligned to the right\n    const mask = ~((1 << delta) - 1);\n    // Join (value left-shifted `bits` bits) with (masked value right-shifted `delta` bits)\n    return ((value << bits) | ((mask & value) >>> delta)) >>> 0;\n}\nfunction fill(dest, index = 0, count = dest.byteLength, value = 0) {\n    for (let i = 0; i < count; i++) {\n        dest[index + i] = value;\n    }\n}\nfunction leftPad(value, length, char = '0') {\n    while (value.length < length) {\n        value = char + value;\n    }\n    return value;\n}\nexport function toHexString(bufferOrValue, bitsize = 32) {\n    if (bufferOrValue instanceof ArrayBuffer) {\n        return Array.from(new Uint8Array(bufferOrValue)).map(b => b.toString(16).padStart(2, '0')).join('');\n    }\n    return leftPad((bufferOrValue >>> 0).toString(16), bitsize / 4);\n}\n/**\n * A SHA1 implementation that works with strings and does not allocate.\n */\nexport class StringSHA1 {\n    constructor() {\n        this._h0 = 0x67452301;\n        this._h1 = 0xEFCDAB89;\n        this._h2 = 0x98BADCFE;\n        this._h3 = 0x10325476;\n        this._h4 = 0xC3D2E1F0;\n        this._buff = new Uint8Array(64 /* BLOCK_SIZE */ + 3 /* to fit any utf-8 */);\n        this._buffDV = new DataView(this._buff.buffer);\n        this._buffLen = 0;\n        this._totalLen = 0;\n        this._leftoverHighSurrogate = 0;\n        this._finished = false;\n    }\n    update(str) {\n        const strLen = str.length;\n        if (strLen === 0) {\n            return;\n        }\n        const buff = this._buff;\n        let buffLen = this._buffLen;\n        let leftoverHighSurrogate = this._leftoverHighSurrogate;\n        let charCode;\n        let offset;\n        if (leftoverHighSurrogate !== 0) {\n            charCode = leftoverHighSurrogate;\n            offset = -1;\n            leftoverHighSurrogate = 0;\n        }\n        else {\n            charCode = str.charCodeAt(0);\n            offset = 0;\n        }\n        while (true) {\n            let codePoint = charCode;\n            if (strings.isHighSurrogate(charCode)) {\n                if (offset + 1 < strLen) {\n                    const nextCharCode = str.charCodeAt(offset + 1);\n                    if (strings.isLowSurrogate(nextCharCode)) {\n                        offset++;\n                        codePoint = strings.computeCodePoint(charCode, nextCharCode);\n                    }\n                    else {\n                        // illegal => unicode replacement character\n                        codePoint = 65533 /* UNICODE_REPLACEMENT */;\n                    }\n                }\n                else {\n                    // last character is a surrogate pair\n                    leftoverHighSurrogate = charCode;\n                    break;\n                }\n            }\n            else if (strings.isLowSurrogate(charCode)) {\n                // illegal => unicode replacement character\n                codePoint = 65533 /* UNICODE_REPLACEMENT */;\n            }\n            buffLen = this._push(buff, buffLen, codePoint);\n            offset++;\n            if (offset < strLen) {\n                charCode = str.charCodeAt(offset);\n            }\n            else {\n                break;\n            }\n        }\n        this._buffLen = buffLen;\n        this._leftoverHighSurrogate = leftoverHighSurrogate;\n    }\n    _push(buff, buffLen, codePoint) {\n        if (codePoint < 0x0080) {\n            buff[buffLen++] = codePoint;\n        }\n        else if (codePoint < 0x0800) {\n            buff[buffLen++] = 0b11000000 | ((codePoint & 0b00000000000000000000011111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else if (codePoint < 0x10000) {\n            buff[buffLen++] = 0b11100000 | ((codePoint & 0b00000000000000001111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        else {\n            buff[buffLen++] = 0b11110000 | ((codePoint & 0b00000000000111000000000000000000) >>> 18);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000111111000000000000) >>> 12);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000111111000000) >>> 6);\n            buff[buffLen++] = 0b10000000 | ((codePoint & 0b00000000000000000000000000111111) >>> 0);\n        }\n        if (buffLen >= 64 /* BLOCK_SIZE */) {\n            this._step();\n            buffLen -= 64 /* BLOCK_SIZE */;\n            this._totalLen += 64 /* BLOCK_SIZE */;\n            // take last 3 in case of UTF8 overflow\n            buff[0] = buff[64 /* BLOCK_SIZE */ + 0];\n            buff[1] = buff[64 /* BLOCK_SIZE */ + 1];\n            buff[2] = buff[64 /* BLOCK_SIZE */ + 2];\n        }\n        return buffLen;\n    }\n    digest() {\n        if (!this._finished) {\n            this._finished = true;\n            if (this._leftoverHighSurrogate) {\n                // illegal => unicode replacement character\n                this._leftoverHighSurrogate = 0;\n                this._buffLen = this._push(this._buff, this._buffLen, 65533 /* UNICODE_REPLACEMENT */);\n            }\n            this._totalLen += this._buffLen;\n            this._wrapUp();\n        }\n        return toHexString(this._h0) + toHexString(this._h1) + toHexString(this._h2) + toHexString(this._h3) + toHexString(this._h4);\n    }\n    _wrapUp() {\n        this._buff[this._buffLen++] = 0x80;\n        fill(this._buff, this._buffLen);\n        if (this._buffLen > 56) {\n            this._step();\n            fill(this._buff);\n        }\n        // this will fit because the mantissa can cover up to 52 bits\n        const ml = 8 * this._totalLen;\n        this._buffDV.setUint32(56, Math.floor(ml / 4294967296), false);\n        this._buffDV.setUint32(60, ml % 4294967296, false);\n        this._step();\n    }\n    _step() {\n        const bigBlock32 = StringSHA1._bigBlock32;\n        const data = this._buffDV;\n        for (let j = 0; j < 64 /* 16*4 */; j += 4) {\n            bigBlock32.setUint32(j, data.getUint32(j, false), false);\n        }\n        for (let j = 64; j < 320 /* 80*4 */; j += 4) {\n            bigBlock32.setUint32(j, leftRotate((bigBlock32.getUint32(j - 12, false) ^ bigBlock32.getUint32(j - 32, false) ^ bigBlock32.getUint32(j - 56, false) ^ bigBlock32.getUint32(j - 64, false)), 1), false);\n        }\n        let a = this._h0;\n        let b = this._h1;\n        let c = this._h2;\n        let d = this._h3;\n        let e = this._h4;\n        let f, k;\n        let temp;\n        for (let j = 0; j < 80; j++) {\n            if (j < 20) {\n                f = (b & c) | ((~b) & d);\n                k = 0x5A827999;\n            }\n            else if (j < 40) {\n                f = b ^ c ^ d;\n                k = 0x6ED9EBA1;\n            }\n            else if (j < 60) {\n                f = (b & c) | (b & d) | (c & d);\n                k = 0x8F1BBCDC;\n            }\n            else {\n                f = b ^ c ^ d;\n                k = 0xCA62C1D6;\n            }\n            temp = (leftRotate(a, 5) + f + e + k + bigBlock32.getUint32(j * 4, false)) & 0xffffffff;\n            e = d;\n            d = c;\n            c = leftRotate(b, 30);\n            b = a;\n            a = temp;\n        }\n        this._h0 = (this._h0 + a) & 0xffffffff;\n        this._h1 = (this._h1 + b) & 0xffffffff;\n        this._h2 = (this._h2 + c) & 0xffffffff;\n        this._h3 = (this._h3 + d) & 0xffffffff;\n        this._h4 = (this._h4 + e) & 0xffffffff;\n    }\n}\nStringSHA1._bigBlock32 = new DataView(new ArrayBuffer(320)); // 80 * 4 = 320\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { DiffChange } from './diffChange.js';\nimport { stringHash } from '../hash.js';\nexport class StringDiffSequence {\n    constructor(source) {\n        this.source = source;\n    }\n    getElements() {\n        const source = this.source;\n        const characters = new Int32Array(source.length);\n        for (let i = 0, len = source.length; i < len; i++) {\n            characters[i] = source.charCodeAt(i);\n        }\n        return characters;\n    }\n}\nexport function stringDiff(original, modified, pretty) {\n    return new LcsDiff(new StringDiffSequence(original), new StringDiffSequence(modified)).ComputeDiff(pretty).changes;\n}\n//\n// The code below has been ported from a C# implementation in VS\n//\nexport class Debug {\n    static Assert(condition, message) {\n        if (!condition) {\n            throw new Error(message);\n        }\n    }\n}\nexport class MyArray {\n    /**\n     * Copies a range of elements from an Array starting at the specified source index and pastes\n     * them to another Array starting at the specified destination index. The length and the indexes\n     * are specified as 64-bit integers.\n     * sourceArray:\n     *\t\tThe Array that contains the data to copy.\n     * sourceIndex:\n     *\t\tA 64-bit integer that represents the index in the sourceArray at which copying begins.\n     * destinationArray:\n     *\t\tThe Array that receives the data.\n     * destinationIndex:\n     *\t\tA 64-bit integer that represents the index in the destinationArray at which storing begins.\n     * length:\n     *\t\tA 64-bit integer that represents the number of elements to copy.\n     */\n    static Copy(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n    static Copy2(sourceArray, sourceIndex, destinationArray, destinationIndex, length) {\n        for (let i = 0; i < length; i++) {\n            destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];\n        }\n    }\n}\n/**\n * A utility class which helps to create the set of DiffChanges from\n * a difference operation. This class accepts original DiffElements and\n * modified DiffElements that are involved in a particular change. The\n * MarkNextChange() method can be called to mark the separation between\n * distinct changes. At the end, the Changes property can be called to retrieve\n * the constructed changes.\n */\nclass DiffChangeHelper {\n    /**\n     * Constructs a new DiffChangeHelper for the given DiffSequences.\n     */\n    constructor() {\n        this.m_changes = [];\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n    }\n    /**\n     * Marks the beginning of the next change in the set of differences.\n     */\n    MarkNextChange() {\n        // Only add to the list if there is something to add\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Add the new change to our list\n            this.m_changes.push(new DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));\n        }\n        // Reset for the next change\n        this.m_originalCount = 0;\n        this.m_modifiedCount = 0;\n        this.m_originalStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n        this.m_modifiedStart = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n    }\n    /**\n     * Adds the original element at the given position to the elements\n     * affected by the current change. The modified index gives context\n     * to the change position with respect to the original sequence.\n     * @param originalIndex The index of the original element to add.\n     * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.\n     */\n    AddOriginalElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_originalCount++;\n    }\n    /**\n     * Adds the modified element at the given position to the elements\n     * affected by the current change. The original index gives context\n     * to the change position with respect to the modified sequence.\n     * @param originalIndex The index of the original element that provides corresponding position in the original sequence.\n     * @param modifiedIndex The index of the modified element to add.\n     */\n    AddModifiedElement(originalIndex, modifiedIndex) {\n        // The 'true' start index is the smallest of the ones we've seen\n        this.m_originalStart = Math.min(this.m_originalStart, originalIndex);\n        this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);\n        this.m_modifiedCount++;\n    }\n    /**\n     * Retrieves all of the changes marked by the class.\n     */\n    getChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        return this.m_changes;\n    }\n    /**\n     * Retrieves all of the changes marked by the class in the reverse order\n     */\n    getReverseChanges() {\n        if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {\n            // Finish up on whatever is left\n            this.MarkNextChange();\n        }\n        this.m_changes.reverse();\n        return this.m_changes;\n    }\n}\n/**\n * An implementation of the difference algorithm described in\n * \"An O(ND) Difference Algorithm and its variations\" by Eugene W. Myers\n */\nexport class LcsDiff {\n    /**\n     * Constructs the DiffFinder\n     */\n    constructor(originalSequence, modifiedSequence, continueProcessingPredicate = null) {\n        this.ContinueProcessingPredicate = continueProcessingPredicate;\n        this._originalSequence = originalSequence;\n        this._modifiedSequence = modifiedSequence;\n        const [originalStringElements, originalElementsOrHash, originalHasStrings] = LcsDiff._getElements(originalSequence);\n        const [modifiedStringElements, modifiedElementsOrHash, modifiedHasStrings] = LcsDiff._getElements(modifiedSequence);\n        this._hasStrings = (originalHasStrings && modifiedHasStrings);\n        this._originalStringElements = originalStringElements;\n        this._originalElementsOrHash = originalElementsOrHash;\n        this._modifiedStringElements = modifiedStringElements;\n        this._modifiedElementsOrHash = modifiedElementsOrHash;\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n    }\n    static _isStringArray(arr) {\n        return (arr.length > 0 && typeof arr[0] === 'string');\n    }\n    static _getElements(sequence) {\n        const elements = sequence.getElements();\n        if (LcsDiff._isStringArray(elements)) {\n            const hashes = new Int32Array(elements.length);\n            for (let i = 0, len = elements.length; i < len; i++) {\n                hashes[i] = stringHash(elements[i], 0);\n            }\n            return [elements, hashes, true];\n        }\n        if (elements instanceof Int32Array) {\n            return [[], elements, false];\n        }\n        return [[], new Int32Array(elements), false];\n    }\n    ElementsAreEqual(originalIndex, newIndex) {\n        if (this._originalElementsOrHash[originalIndex] !== this._modifiedElementsOrHash[newIndex]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[originalIndex] === this._modifiedStringElements[newIndex] : true);\n    }\n    ElementsAreStrictEqual(originalIndex, newIndex) {\n        if (!this.ElementsAreEqual(originalIndex, newIndex)) {\n            return false;\n        }\n        const originalElement = LcsDiff._getStrictElement(this._originalSequence, originalIndex);\n        const modifiedElement = LcsDiff._getStrictElement(this._modifiedSequence, newIndex);\n        return (originalElement === modifiedElement);\n    }\n    static _getStrictElement(sequence, index) {\n        if (typeof sequence.getStrictElement === 'function') {\n            return sequence.getStrictElement(index);\n        }\n        return null;\n    }\n    OriginalElementsAreEqual(index1, index2) {\n        if (this._originalElementsOrHash[index1] !== this._originalElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._originalStringElements[index1] === this._originalStringElements[index2] : true);\n    }\n    ModifiedElementsAreEqual(index1, index2) {\n        if (this._modifiedElementsOrHash[index1] !== this._modifiedElementsOrHash[index2]) {\n            return false;\n        }\n        return (this._hasStrings ? this._modifiedStringElements[index1] === this._modifiedStringElements[index2] : true);\n    }\n    ComputeDiff(pretty) {\n        return this._ComputeDiff(0, this._originalElementsOrHash.length - 1, 0, this._modifiedElementsOrHash.length - 1, pretty);\n    }\n    /**\n     * Computes the differences between the original and modified input\n     * sequences on the bounded range.\n     * @returns An array of the differences between the two input sequences.\n     */\n    _ComputeDiff(originalStart, originalEnd, modifiedStart, modifiedEnd, pretty) {\n        const quitEarlyArr = [false];\n        let changes = this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);\n        if (pretty) {\n            // We have to clean up the computed diff to be more intuitive\n            // but it turns out this cannot be done correctly until the entire set\n            // of diffs have been computed\n            changes = this.PrettifyChanges(changes);\n        }\n        return {\n            quitEarly: quitEarlyArr[0],\n            changes: changes\n        };\n    }\n    /**\n     * Private helper method which computes the differences on the bounded range\n     * recursively.\n     * @returns An array of the differences between the two input sequences.\n     */\n    ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {\n        quitEarlyArr[0] = false;\n        // Find the start of the differences\n        while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {\n            originalStart++;\n            modifiedStart++;\n        }\n        // Find the end of the differences\n        while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {\n            originalEnd--;\n            modifiedEnd--;\n        }\n        // In the special case where we either have all insertions or all deletions or the sequences are identical\n        if (originalStart > originalEnd || modifiedStart > modifiedEnd) {\n            let changes;\n            if (modifiedStart <= modifiedEnd) {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                // All insertions\n                changes = [\n                    new DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)\n                ];\n            }\n            else if (originalStart <= originalEnd) {\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // All deletions\n                changes = [\n                    new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)\n                ];\n            }\n            else {\n                Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');\n                Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');\n                // Identical sequences - No differences\n                changes = [];\n            }\n            return changes;\n        }\n        // This problem can be solved using the Divide-And-Conquer technique.\n        const midOriginalArr = [0];\n        const midModifiedArr = [0];\n        const result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);\n        const midOriginal = midOriginalArr[0];\n        const midModified = midModifiedArr[0];\n        if (result !== null) {\n            // Result is not-null when there was enough memory to compute the changes while\n            // searching for the recursion point\n            return result;\n        }\n        else if (!quitEarlyArr[0]) {\n            // We can break the problem down recursively by finding the changes in the\n            // First Half:   (originalStart, modifiedStart) to (midOriginal, midModified)\n            // Second Half:  (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)\n            // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point\n            const leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);\n            let rightChanges = [];\n            if (!quitEarlyArr[0]) {\n                rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);\n            }\n            else {\n                // We didn't have time to finish the first half, so we don't have time to compute this half.\n                // Consider the entire rest of the sequence different.\n                rightChanges = [\n                    new DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)\n                ];\n            }\n            return this.ConcatenateChanges(leftChanges, rightChanges);\n        }\n        // If we hit here, we quit early, and so can't return anything meaningful\n        return [\n            new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n        ];\n    }\n    WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {\n        let forwardChanges = null;\n        let reverseChanges = null;\n        // First, walk backward through the forward diagonals history\n        let changeHelper = new DiffChangeHelper();\n        let diagonalMin = diagonalForwardStart;\n        let diagonalMax = diagonalForwardEnd;\n        let diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;\n        let lastOriginalIndex = -1073741824 /* MIN_SAFE_SMALL_INTEGER */;\n        let historyIndex = this.m_forwardHistory.length - 1;\n        do {\n            // Get the diagonal index from the relative diagonal number\n            const diagonal = diagonalRelative + diagonalForwardBase;\n            // Figure out where we came from\n            if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                // Vertical line (the element is an insert)\n                originalIndex = forwardPoints[diagonal + 1];\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex;\n                changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);\n                diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            else {\n                // Horizontal line (the element is a deletion)\n                originalIndex = forwardPoints[diagonal - 1] + 1;\n                modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;\n                if (originalIndex < lastOriginalIndex) {\n                    changeHelper.MarkNextChange();\n                }\n                lastOriginalIndex = originalIndex - 1;\n                changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);\n                diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration\n            }\n            if (historyIndex >= 0) {\n                forwardPoints = this.m_forwardHistory[historyIndex];\n                diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot\n                diagonalMin = 1;\n                diagonalMax = forwardPoints.length - 1;\n            }\n        } while (--historyIndex >= -1);\n        // Ironically, we get the forward changes as the reverse of the\n        // order we added them since we technically added them backwards\n        forwardChanges = changeHelper.getReverseChanges();\n        if (quitEarlyArr[0]) {\n            // TODO: Calculate a partial from the reverse diagonals.\n            //       For now, just assume everything after the midOriginal/midModified point is a diff\n            let originalStartPoint = midOriginalArr[0] + 1;\n            let modifiedStartPoint = midModifiedArr[0] + 1;\n            if (forwardChanges !== null && forwardChanges.length > 0) {\n                const lastForwardChange = forwardChanges[forwardChanges.length - 1];\n                originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());\n                modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());\n            }\n            reverseChanges = [\n                new DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)\n            ];\n        }\n        else {\n            // Now walk backward through the reverse diagonals history\n            changeHelper = new DiffChangeHelper();\n            diagonalMin = diagonalReverseStart;\n            diagonalMax = diagonalReverseEnd;\n            diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;\n            lastOriginalIndex = 1073741824 /* MAX_SAFE_SMALL_INTEGER */;\n            historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;\n            do {\n                // Get the diagonal index from the relative diagonal number\n                const diagonal = diagonalRelative + diagonalReverseBase;\n                // Figure out where we came from\n                if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    // Horizontal line (the element is a deletion))\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex + 1;\n                    changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                else {\n                    // Vertical line (the element is an insertion)\n                    originalIndex = reversePoints[diagonal - 1];\n                    modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;\n                    if (originalIndex > lastOriginalIndex) {\n                        changeHelper.MarkNextChange();\n                    }\n                    lastOriginalIndex = originalIndex;\n                    changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);\n                    diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration\n                }\n                if (historyIndex >= 0) {\n                    reversePoints = this.m_reverseHistory[historyIndex];\n                    diagonalReverseBase = reversePoints[0]; //We stored this in the first spot\n                    diagonalMin = 1;\n                    diagonalMax = reversePoints.length - 1;\n                }\n            } while (--historyIndex >= -1);\n            // There are cases where the reverse history will find diffs that\n            // are correct, but not intuitive, so we need shift them.\n            reverseChanges = changeHelper.getChanges();\n        }\n        return this.ConcatenateChanges(forwardChanges, reverseChanges);\n    }\n    /**\n     * Given the range to compute the diff on, this method finds the point:\n     * (midOriginal, midModified)\n     * that exists in the middle of the LCS of the two sequences and\n     * is the point at which the LCS problem may be broken down recursively.\n     * This method will try to keep the LCS trace in memory. If the LCS recursion\n     * point is calculated and the full trace is available in memory, then this method\n     * will return the change list.\n     * @param originalStart The start bound of the original sequence range\n     * @param originalEnd The end bound of the original sequence range\n     * @param modifiedStart The start bound of the modified sequence range\n     * @param modifiedEnd The end bound of the modified sequence range\n     * @param midOriginal The middle point of the original sequence range\n     * @param midModified The middle point of the modified sequence range\n     * @returns The diff changes, if available, otherwise null\n     */\n    ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {\n        let originalIndex = 0, modifiedIndex = 0;\n        let diagonalForwardStart = 0, diagonalForwardEnd = 0;\n        let diagonalReverseStart = 0, diagonalReverseEnd = 0;\n        // To traverse the edit graph and produce the proper LCS, our actual\n        // start position is just outside the given boundary\n        originalStart--;\n        modifiedStart--;\n        // We set these up to make the compiler happy, but they will\n        // be replaced before we return with the actual recursion point\n        midOriginalArr[0] = 0;\n        midModifiedArr[0] = 0;\n        // Clear out the history\n        this.m_forwardHistory = [];\n        this.m_reverseHistory = [];\n        // Each cell in the two arrays corresponds to a diagonal in the edit graph.\n        // The integer value in the cell represents the originalIndex of the furthest\n        // reaching point found so far that ends in that diagonal.\n        // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.\n        const maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);\n        const numDiagonals = maxDifferences + 1;\n        const forwardPoints = new Int32Array(numDiagonals);\n        const reversePoints = new Int32Array(numDiagonals);\n        // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)\n        // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)\n        const diagonalForwardBase = (modifiedEnd - modifiedStart);\n        const diagonalReverseBase = (originalEnd - originalStart);\n        // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalForwardBase)\n        // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the\n        //    diagonal number (relative to diagonalReverseBase)\n        const diagonalForwardOffset = (originalStart - modifiedStart);\n        const diagonalReverseOffset = (originalEnd - modifiedEnd);\n        // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers\n        //   relative to the start diagonal with diagonal numbers relative to the end diagonal.\n        // The Even/Oddn-ness of this delta is important for determining when we should check for overlap\n        const delta = diagonalReverseBase - diagonalForwardBase;\n        const deltaIsEven = (delta % 2 === 0);\n        // Here we set up the start and end points as the furthest points found so far\n        // in both the forward and reverse directions, respectively\n        forwardPoints[diagonalForwardBase] = originalStart;\n        reversePoints[diagonalReverseBase] = originalEnd;\n        // Remember if we quit early, and thus need to do a best-effort result instead of a real result.\n        quitEarlyArr[0] = false;\n        // A couple of points:\n        // --With this method, we iterate on the number of differences between the two sequences.\n        //   The more differences there actually are, the longer this will take.\n        // --Also, as the number of differences increases, we have to search on diagonals further\n        //   away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).\n        // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences\n        //   is even and odd diagonals only when numDifferences is odd.\n        for (let numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {\n            let furthestOriginalIndex = 0;\n            let furthestModifiedIndex = 0;\n            // Run the algorithm in the forward direction\n            diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);\n            for (let diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalStart, modifiedStart)\n                if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {\n                    originalIndex = forwardPoints[diagonal + 1];\n                }\n                else {\n                    originalIndex = forwardPoints[diagonal - 1] + 1;\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;\n                // Save the current originalIndex so we can test for false overlap in step 3\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // so long as the elements are equal.\n                while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {\n                    originalIndex++;\n                    modifiedIndex++;\n                }\n                forwardPoints[diagonal] = originalIndex;\n                if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {\n                    furthestOriginalIndex = originalIndex;\n                    furthestModifiedIndex = modifiedIndex;\n                }\n                // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)\n                // and diagonal is in the range of reverse diagonals computed for numDifferences-1\n                // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)\n                // then check for overlap.\n                if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {\n                    if (originalIndex >= reversePoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex <= reversePoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Check to see if we should be quitting early, before moving on to the next iteration.\n            const matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;\n            if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, matchLengthOfLongest)) {\n                // We can't finish, so skip ahead to generating a result from what we have.\n                quitEarlyArr[0] = true;\n                // Use the furthest distance we got in the forward direction.\n                midOriginalArr[0] = furthestOriginalIndex;\n                midModifiedArr[0] = furthestModifiedIndex;\n                if (matchLengthOfLongest > 0 && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                    // Enough of the history is in memory to walk it backwards\n                    return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                }\n                else {\n                    // We didn't actually remember enough of the history.\n                    //Since we are quitting the diff early, we need to shift back the originalStart and modified start\n                    //back into the boundary limits since we decremented their value above beyond the boundary limit.\n                    originalStart++;\n                    modifiedStart++;\n                    return [\n                        new DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)\n                    ];\n                }\n            }\n            // Run the algorithm in the reverse direction\n            diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);\n            for (let diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {\n                // STEP 1: We extend the furthest reaching point in the present diagonal\n                // by looking at the diagonals above and below and picking the one whose point\n                // is further away from the start point (originalEnd, modifiedEnd)\n                if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {\n                    originalIndex = reversePoints[diagonal + 1] - 1;\n                }\n                else {\n                    originalIndex = reversePoints[diagonal - 1];\n                }\n                modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;\n                // Save the current originalIndex so we can test for false overlap\n                const tempOriginalIndex = originalIndex;\n                // STEP 2: We can continue to extend the furthest reaching point in the present diagonal\n                // as long as the elements are equal.\n                while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {\n                    originalIndex--;\n                    modifiedIndex--;\n                }\n                reversePoints[diagonal] = originalIndex;\n                // STEP 4: If delta is even (overlap first happens on reverse when delta is even)\n                // and diagonal is in the range of forward diagonals computed for numDifferences\n                // then check for overlap.\n                if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {\n                    if (originalIndex <= forwardPoints[diagonal]) {\n                        midOriginalArr[0] = originalIndex;\n                        midModifiedArr[0] = modifiedIndex;\n                        if (tempOriginalIndex >= forwardPoints[diagonal] && 1447 /* MaxDifferencesHistory */ > 0 && numDifferences <= (1447 /* MaxDifferencesHistory */ + 1)) {\n                            // BINGO! We overlapped, and we have the full trace in memory!\n                            return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n                        }\n                        else {\n                            // Either false overlap, or we didn't have enough memory for the full trace\n                            // Just return the recursion point\n                            return null;\n                        }\n                    }\n                }\n            }\n            // Save current vectors to history before the next iteration\n            if (numDifferences <= 1447 /* MaxDifferencesHistory */) {\n                // We are allocating space for one extra int, which we fill with\n                // the index of the diagonal base index\n                let temp = new Int32Array(diagonalForwardEnd - diagonalForwardStart + 2);\n                temp[0] = diagonalForwardBase - diagonalForwardStart + 1;\n                MyArray.Copy2(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);\n                this.m_forwardHistory.push(temp);\n                temp = new Int32Array(diagonalReverseEnd - diagonalReverseStart + 2);\n                temp[0] = diagonalReverseBase - diagonalReverseStart + 1;\n                MyArray.Copy2(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);\n                this.m_reverseHistory.push(temp);\n            }\n        }\n        // If we got here, then we have the full trace in history. We just have to convert it to a change list\n        // NOTE: This part is a bit messy\n        return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);\n    }\n    /**\n     * Shifts the given changes to provide a more intuitive diff.\n     * While the first element in a diff matches the first element after the diff,\n     * we shift the diff down.\n     *\n     * @param changes The list of changes to shift\n     * @returns The shifted changes\n     */\n    PrettifyChanges(changes) {\n        // Shift all the changes down first\n        for (let i = 0; i < changes.length; i++) {\n            const change = changes[i];\n            const originalStop = (i < changes.length - 1) ? changes[i + 1].originalStart : this._originalElementsOrHash.length;\n            const modifiedStop = (i < changes.length - 1) ? changes[i + 1].modifiedStart : this._modifiedElementsOrHash.length;\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            while (change.originalStart + change.originalLength < originalStop\n                && change.modifiedStart + change.modifiedLength < modifiedStop\n                && (!checkOriginal || this.OriginalElementsAreEqual(change.originalStart, change.originalStart + change.originalLength))\n                && (!checkModified || this.ModifiedElementsAreEqual(change.modifiedStart, change.modifiedStart + change.modifiedLength))) {\n                const startStrictEqual = this.ElementsAreStrictEqual(change.originalStart, change.modifiedStart);\n                const endStrictEqual = this.ElementsAreStrictEqual(change.originalStart + change.originalLength, change.modifiedStart + change.modifiedLength);\n                if (endStrictEqual && !startStrictEqual) {\n                    // moving the change down would create an equal change, but the elements are not strict equal\n                    break;\n                }\n                change.originalStart++;\n                change.modifiedStart++;\n            }\n            let mergedChangeArr = [null];\n            if (i < changes.length - 1 && this.ChangesOverlap(changes[i], changes[i + 1], mergedChangeArr)) {\n                changes[i] = mergedChangeArr[0];\n                changes.splice(i + 1, 1);\n                i--;\n                continue;\n            }\n        }\n        // Shift changes back up until we hit empty or whitespace-only lines\n        for (let i = changes.length - 1; i >= 0; i--) {\n            const change = changes[i];\n            let originalStop = 0;\n            let modifiedStop = 0;\n            if (i > 0) {\n                const prevChange = changes[i - 1];\n                originalStop = prevChange.originalStart + prevChange.originalLength;\n                modifiedStop = prevChange.modifiedStart + prevChange.modifiedLength;\n            }\n            const checkOriginal = change.originalLength > 0;\n            const checkModified = change.modifiedLength > 0;\n            let bestDelta = 0;\n            let bestScore = this._boundaryScore(change.originalStart, change.originalLength, change.modifiedStart, change.modifiedLength);\n            for (let delta = 1;; delta++) {\n                const originalStart = change.originalStart - delta;\n                const modifiedStart = change.modifiedStart - delta;\n                if (originalStart < originalStop || modifiedStart < modifiedStop) {\n                    break;\n                }\n                if (checkOriginal && !this.OriginalElementsAreEqual(originalStart, originalStart + change.originalLength)) {\n                    break;\n                }\n                if (checkModified && !this.ModifiedElementsAreEqual(modifiedStart, modifiedStart + change.modifiedLength)) {\n                    break;\n                }\n                const touchingPreviousChange = (originalStart === originalStop && modifiedStart === modifiedStop);\n                const score = ((touchingPreviousChange ? 5 : 0)\n                    + this._boundaryScore(originalStart, change.originalLength, modifiedStart, change.modifiedLength));\n                if (score > bestScore) {\n                    bestScore = score;\n                    bestDelta = delta;\n                }\n            }\n            change.originalStart -= bestDelta;\n            change.modifiedStart -= bestDelta;\n            const mergedChangeArr = [null];\n            if (i > 0 && this.ChangesOverlap(changes[i - 1], changes[i], mergedChangeArr)) {\n                changes[i - 1] = mergedChangeArr[0];\n                changes.splice(i, 1);\n                i++;\n                continue;\n            }\n        }\n        // There could be multiple longest common substrings.\n        // Give preference to the ones containing longer lines\n        if (this._hasStrings) {\n            for (let i = 1, len = changes.length; i < len; i++) {\n                const aChange = changes[i - 1];\n                const bChange = changes[i];\n                const matchedLength = bChange.originalStart - aChange.originalStart - aChange.originalLength;\n                const aOriginalStart = aChange.originalStart;\n                const bOriginalEnd = bChange.originalStart + bChange.originalLength;\n                const abOriginalLength = bOriginalEnd - aOriginalStart;\n                const aModifiedStart = aChange.modifiedStart;\n                const bModifiedEnd = bChange.modifiedStart + bChange.modifiedLength;\n                const abModifiedLength = bModifiedEnd - aModifiedStart;\n                // Avoid wasting a lot of time with these searches\n                if (matchedLength < 5 && abOriginalLength < 20 && abModifiedLength < 20) {\n                    const t = this._findBetterContiguousSequence(aOriginalStart, abOriginalLength, aModifiedStart, abModifiedLength, matchedLength);\n                    if (t) {\n                        const [originalMatchStart, modifiedMatchStart] = t;\n                        if (originalMatchStart !== aChange.originalStart + aChange.originalLength || modifiedMatchStart !== aChange.modifiedStart + aChange.modifiedLength) {\n                            // switch to another sequence that has a better score\n                            aChange.originalLength = originalMatchStart - aChange.originalStart;\n                            aChange.modifiedLength = modifiedMatchStart - aChange.modifiedStart;\n                            bChange.originalStart = originalMatchStart + matchedLength;\n                            bChange.modifiedStart = modifiedMatchStart + matchedLength;\n                            bChange.originalLength = bOriginalEnd - bChange.originalStart;\n                            bChange.modifiedLength = bModifiedEnd - bChange.modifiedStart;\n                        }\n                    }\n                }\n            }\n        }\n        return changes;\n    }\n    _findBetterContiguousSequence(originalStart, originalLength, modifiedStart, modifiedLength, desiredLength) {\n        if (originalLength < desiredLength || modifiedLength < desiredLength) {\n            return null;\n        }\n        const originalMax = originalStart + originalLength - desiredLength + 1;\n        const modifiedMax = modifiedStart + modifiedLength - desiredLength + 1;\n        let bestScore = 0;\n        let bestOriginalStart = 0;\n        let bestModifiedStart = 0;\n        for (let i = originalStart; i < originalMax; i++) {\n            for (let j = modifiedStart; j < modifiedMax; j++) {\n                const score = this._contiguousSequenceScore(i, j, desiredLength);\n                if (score > 0 && score > bestScore) {\n                    bestScore = score;\n                    bestOriginalStart = i;\n                    bestModifiedStart = j;\n                }\n            }\n        }\n        if (bestScore > 0) {\n            return [bestOriginalStart, bestModifiedStart];\n        }\n        return null;\n    }\n    _contiguousSequenceScore(originalStart, modifiedStart, length) {\n        let score = 0;\n        for (let l = 0; l < length; l++) {\n            if (!this.ElementsAreEqual(originalStart + l, modifiedStart + l)) {\n                return 0;\n            }\n            score += this._originalStringElements[originalStart + l].length;\n        }\n        return score;\n    }\n    _OriginalIsBoundary(index) {\n        if (index <= 0 || index >= this._originalElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._originalStringElements[index]));\n    }\n    _OriginalRegionIsBoundary(originalStart, originalLength) {\n        if (this._OriginalIsBoundary(originalStart) || this._OriginalIsBoundary(originalStart - 1)) {\n            return true;\n        }\n        if (originalLength > 0) {\n            const originalEnd = originalStart + originalLength;\n            if (this._OriginalIsBoundary(originalEnd - 1) || this._OriginalIsBoundary(originalEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _ModifiedIsBoundary(index) {\n        if (index <= 0 || index >= this._modifiedElementsOrHash.length - 1) {\n            return true;\n        }\n        return (this._hasStrings && /^\\s*$/.test(this._modifiedStringElements[index]));\n    }\n    _ModifiedRegionIsBoundary(modifiedStart, modifiedLength) {\n        if (this._ModifiedIsBoundary(modifiedStart) || this._ModifiedIsBoundary(modifiedStart - 1)) {\n            return true;\n        }\n        if (modifiedLength > 0) {\n            const modifiedEnd = modifiedStart + modifiedLength;\n            if (this._ModifiedIsBoundary(modifiedEnd - 1) || this._ModifiedIsBoundary(modifiedEnd)) {\n                return true;\n            }\n        }\n        return false;\n    }\n    _boundaryScore(originalStart, originalLength, modifiedStart, modifiedLength) {\n        const originalScore = (this._OriginalRegionIsBoundary(originalStart, originalLength) ? 1 : 0);\n        const modifiedScore = (this._ModifiedRegionIsBoundary(modifiedStart, modifiedLength) ? 1 : 0);\n        return (originalScore + modifiedScore);\n    }\n    /**\n     * Concatenates the two input DiffChange lists and returns the resulting\n     * list.\n     * @param The left changes\n     * @param The right changes\n     * @returns The concatenated list\n     */\n    ConcatenateChanges(left, right) {\n        let mergedChangeArr = [];\n        if (left.length === 0 || right.length === 0) {\n            return (right.length > 0) ? right : left;\n        }\n        else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {\n            // Since we break the problem down recursively, it is possible that we\n            // might recurse in the middle of a change thereby splitting it into\n            // two changes. Here in the combining stage, we detect and fuse those\n            // changes back together\n            const result = new Array(left.length + right.length - 1);\n            MyArray.Copy(left, 0, result, 0, left.length - 1);\n            result[left.length - 1] = mergedChangeArr[0];\n            MyArray.Copy(right, 1, result, left.length, right.length - 1);\n            return result;\n        }\n        else {\n            const result = new Array(left.length + right.length);\n            MyArray.Copy(left, 0, result, 0, left.length);\n            MyArray.Copy(right, 0, result, left.length, right.length);\n            return result;\n        }\n    }\n    /**\n     * Returns true if the two changes overlap and can be merged into a single\n     * change\n     * @param left The left change\n     * @param right The right change\n     * @param mergedChange The merged change if the two overlap, null otherwise\n     * @returns True if the two changes overlap\n     */\n    ChangesOverlap(left, right, mergedChangeArr) {\n        Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');\n        Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');\n        if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n            const originalStart = left.originalStart;\n            let originalLength = left.originalLength;\n            const modifiedStart = left.modifiedStart;\n            let modifiedLength = left.modifiedLength;\n            if (left.originalStart + left.originalLength >= right.originalStart) {\n                originalLength = right.originalStart + right.originalLength - left.originalStart;\n            }\n            if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {\n                modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;\n            }\n            mergedChangeArr[0] = new DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);\n            return true;\n        }\n        else {\n            mergedChangeArr[0] = null;\n            return false;\n        }\n    }\n    /**\n     * Helper method used to clip a diagonal index to the range of valid\n     * diagonals. This also decides whether or not the diagonal index,\n     * if it exceeds the boundary, should be clipped to the boundary or clipped\n     * one inside the boundary depending on the Even/Odd status of the boundary\n     * and numDifferences.\n     * @param diagonal The index of the diagonal to clip.\n     * @param numDifferences The current number of differences being iterated upon.\n     * @param diagonalBaseIndex The base reference diagonal.\n     * @param numDiagonals The total number of diagonals.\n     * @returns The clipped diagonal index.\n     */\n    ClipDiagonalBound(diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {\n        if (diagonal >= 0 && diagonal < numDiagonals) {\n            // Nothing to clip, its in range\n            return diagonal;\n        }\n        // diagonalsBelow: The number of diagonals below the reference diagonal\n        // diagonalsAbove: The number of diagonals above the reference diagonal\n        const diagonalsBelow = diagonalBaseIndex;\n        const diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;\n        const diffEven = (numDifferences % 2 === 0);\n        if (diagonal < 0) {\n            const lowerBoundEven = (diagonalsBelow % 2 === 0);\n            return (diffEven === lowerBoundEven) ? 0 : 1;\n        }\n        else {\n            const upperBoundEven = (diagonalsAbove % 2 === 0);\n            return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// NOTE: VSCode's copy of nodejs path library to be usable in common (non-node) namespace\n// Copied from: https://github.com/nodejs/node/blob/v14.16.0/lib/path.js\n/**\n * Copyright Joyent, Inc. and other Node contributors.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to permit\n * persons to whom the Software is furnished to do so, subject to the\n * following conditions:\n *\n * The above copyright notice and this permission notice shall be included\n * in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n * NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n * USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\nimport * as process from './process.js';\nconst CHAR_UPPERCASE_A = 65; /* A */\nconst CHAR_LOWERCASE_A = 97; /* a */\nconst CHAR_UPPERCASE_Z = 90; /* Z */\nconst CHAR_LOWERCASE_Z = 122; /* z */\nconst CHAR_DOT = 46; /* . */\nconst CHAR_FORWARD_SLASH = 47; /* / */\nconst CHAR_BACKWARD_SLASH = 92; /* \\ */\nconst CHAR_COLON = 58; /* : */\nconst CHAR_QUESTION_MARK = 63; /* ? */\nclass ErrorInvalidArgType extends Error {\n    constructor(name, expected, actual) {\n        // determiner: 'must be' or 'must not be'\n        let determiner;\n        if (typeof expected === 'string' && expected.indexOf('not ') === 0) {\n            determiner = 'must not be';\n            expected = expected.replace(/^not /, '');\n        }\n        else {\n            determiner = 'must be';\n        }\n        const type = name.indexOf('.') !== -1 ? 'property' : 'argument';\n        let msg = `The \"${name}\" ${type} ${determiner} of type ${expected}`;\n        msg += `. Received type ${typeof actual}`;\n        super(msg);\n        this.code = 'ERR_INVALID_ARG_TYPE';\n    }\n}\nfunction validateString(value, name) {\n    if (typeof value !== 'string') {\n        throw new ErrorInvalidArgType(name, 'string', value);\n    }\n}\nfunction isPathSeparator(code) {\n    return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;\n}\nfunction isPosixPathSeparator(code) {\n    return code === CHAR_FORWARD_SLASH;\n}\nfunction isWindowsDeviceRoot(code) {\n    return (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||\n        (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z);\n}\n// Resolves . and .. elements in a path with directory names\nfunction normalizeString(path, allowAboveRoot, separator, isPathSeparator) {\n    let res = '';\n    let lastSegmentLength = 0;\n    let lastSlash = -1;\n    let dots = 0;\n    let code = 0;\n    for (let i = 0; i <= path.length; ++i) {\n        if (i < path.length) {\n            code = path.charCodeAt(i);\n        }\n        else if (isPathSeparator(code)) {\n            break;\n        }\n        else {\n            code = CHAR_FORWARD_SLASH;\n        }\n        if (isPathSeparator(code)) {\n            if (lastSlash === i - 1 || dots === 1) {\n                // NOOP\n            }\n            else if (dots === 2) {\n                if (res.length < 2 || lastSegmentLength !== 2 ||\n                    res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n                    res.charCodeAt(res.length - 2) !== CHAR_DOT) {\n                    if (res.length > 2) {\n                        const lastSlashIndex = res.lastIndexOf(separator);\n                        if (lastSlashIndex === -1) {\n                            res = '';\n                            lastSegmentLength = 0;\n                        }\n                        else {\n                            res = res.slice(0, lastSlashIndex);\n                            lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n                        }\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                    else if (res.length !== 0) {\n                        res = '';\n                        lastSegmentLength = 0;\n                        lastSlash = i;\n                        dots = 0;\n                        continue;\n                    }\n                }\n                if (allowAboveRoot) {\n                    res += res.length > 0 ? `${separator}..` : '..';\n                    lastSegmentLength = 2;\n                }\n            }\n            else {\n                if (res.length > 0) {\n                    res += `${separator}${path.slice(lastSlash + 1, i)}`;\n                }\n                else {\n                    res = path.slice(lastSlash + 1, i);\n                }\n                lastSegmentLength = i - lastSlash - 1;\n            }\n            lastSlash = i;\n            dots = 0;\n        }\n        else if (code === CHAR_DOT && dots !== -1) {\n            ++dots;\n        }\n        else {\n            dots = -1;\n        }\n    }\n    return res;\n}\nfunction _format(sep, pathObject) {\n    if (pathObject === null || typeof pathObject !== 'object') {\n        throw new ErrorInvalidArgType('pathObject', 'Object', pathObject);\n    }\n    const dir = pathObject.dir || pathObject.root;\n    const base = pathObject.base ||\n        `${pathObject.name || ''}${pathObject.ext || ''}`;\n    if (!dir) {\n        return base;\n    }\n    return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;\n}\nexport const win32 = {\n    // path.resolve([from ...], to)\n    resolve(...pathSegments) {\n        let resolvedDevice = '';\n        let resolvedTail = '';\n        let resolvedAbsolute = false;\n        for (let i = pathSegments.length - 1; i >= -1; i--) {\n            let path;\n            if (i >= 0) {\n                path = pathSegments[i];\n                validateString(path, 'path');\n                // Skip empty entries\n                if (path.length === 0) {\n                    continue;\n                }\n            }\n            else if (resolvedDevice.length === 0) {\n                path = process.cwd();\n            }\n            else {\n                // Windows has the concept of drive-specific current working\n                // directories. If we've resolved a drive letter but not yet an\n                // absolute path, get cwd for that drive, or the process cwd if\n                // the drive cwd is not available. We're sure the device is not\n                // a UNC path at this points, because UNC paths are always absolute.\n                path = process.env[`=${resolvedDevice}`] || process.cwd();\n                // Verify that a cwd was found and that it actually points\n                // to our drive. If not, default to the drive's root.\n                if (path === undefined ||\n                    (path.slice(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() &&\n                        path.charCodeAt(2) === CHAR_BACKWARD_SLASH)) {\n                    path = `${resolvedDevice}\\\\`;\n                }\n            }\n            const len = path.length;\n            let rootEnd = 0;\n            let device = '';\n            let isAbsolute = false;\n            const code = path.charCodeAt(0);\n            // Try to match a root\n            if (len === 1) {\n                if (isPathSeparator(code)) {\n                    // `path` contains just a path separator\n                    rootEnd = 1;\n                    isAbsolute = true;\n                }\n            }\n            else if (isPathSeparator(code)) {\n                // Possible UNC root\n                // If we started with a separator, we know we at least have an\n                // absolute path of some kind (UNC or otherwise)\n                isAbsolute = true;\n                if (isPathSeparator(path.charCodeAt(1))) {\n                    // Matched double path separator at beginning\n                    let j = 2;\n                    let last = j;\n                    // Match 1 or more non-path separators\n                    while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        const firstPart = path.slice(last, j);\n                        // Matched!\n                        last = j;\n                        // Match 1 or more path separators\n                        while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j < len && j !== last) {\n                            // Matched!\n                            last = j;\n                            // Match 1 or more non-path separators\n                            while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                                j++;\n                            }\n                            if (j === len || j !== last) {\n                                // We matched a UNC root\n                                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                                rootEnd = j;\n                            }\n                        }\n                    }\n                }\n                else {\n                    rootEnd = 1;\n                }\n            }\n            else if (isWindowsDeviceRoot(code) &&\n                path.charCodeAt(1) === CHAR_COLON) {\n                // Possible device root\n                device = path.slice(0, 2);\n                rootEnd = 2;\n                if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n                    // Treat separator following drive name as an absolute path\n                    // indicator\n                    isAbsolute = true;\n                    rootEnd = 3;\n                }\n            }\n            if (device.length > 0) {\n                if (resolvedDevice.length > 0) {\n                    if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {\n                        // This path points to another device so it is not applicable\n                        continue;\n                    }\n                }\n                else {\n                    resolvedDevice = device;\n                }\n            }\n            if (resolvedAbsolute) {\n                if (resolvedDevice.length > 0) {\n                    break;\n                }\n            }\n            else {\n                resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n                resolvedAbsolute = isAbsolute;\n                if (isAbsolute && resolvedDevice.length > 0) {\n                    break;\n                }\n            }\n        }\n        // At this point the path should be resolved to a full absolute path,\n        // but handle relative paths to be safe (might happen when process.cwd()\n        // fails)\n        // Normalize the tail path\n        resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, '\\\\', isPathSeparator);\n        return resolvedAbsolute ?\n            `${resolvedDevice}\\\\${resolvedTail}` :\n            `${resolvedDevice}${resolvedTail}` || '.';\n    },\n    normalize(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return '.';\n        }\n        let rootEnd = 0;\n        let device;\n        let isAbsolute = false;\n        const code = path.charCodeAt(0);\n        // Try to match a root\n        if (len === 1) {\n            // `path` contains just a single char, exit early to avoid\n            // unnecessary work\n            return isPosixPathSeparator(code) ? '\\\\' : path;\n        }\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            // If we started with a separator, we know we at least have an absolute\n            // path of some kind (UNC or otherwise)\n            isAbsolute = true;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    const firstPart = path.slice(last, j);\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            // Return the normalized version of the UNC root since there\n                            // is nothing left to process\n                            return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n                        }\n                        if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                            rootEnd = j;\n                        }\n                    }\n                }\n            }\n            else {\n                rootEnd = 1;\n            }\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            // Possible device root\n            device = path.slice(0, 2);\n            rootEnd = 2;\n            if (len > 2 && isPathSeparator(path.charCodeAt(2))) {\n                // Treat separator following drive name as an absolute path\n                // indicator\n                isAbsolute = true;\n                rootEnd = 3;\n            }\n        }\n        let tail = rootEnd < len ?\n            normalizeString(path.slice(rootEnd), !isAbsolute, '\\\\', isPathSeparator) :\n            '';\n        if (tail.length === 0 && !isAbsolute) {\n            tail = '.';\n        }\n        if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n            tail += '\\\\';\n        }\n        if (device === undefined) {\n            return isAbsolute ? `\\\\${tail}` : tail;\n        }\n        return isAbsolute ? `${device}\\\\${tail}` : `${device}${tail}`;\n    },\n    isAbsolute(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return false;\n        }\n        const code = path.charCodeAt(0);\n        return isPathSeparator(code) ||\n            // Possible device root\n            (len > 2 &&\n                isWindowsDeviceRoot(code) &&\n                path.charCodeAt(1) === CHAR_COLON &&\n                isPathSeparator(path.charCodeAt(2)));\n    },\n    join(...paths) {\n        if (paths.length === 0) {\n            return '.';\n        }\n        let joined;\n        let firstPart;\n        for (let i = 0; i < paths.length; ++i) {\n            const arg = paths[i];\n            validateString(arg, 'path');\n            if (arg.length > 0) {\n                if (joined === undefined) {\n                    joined = firstPart = arg;\n                }\n                else {\n                    joined += `\\\\${arg}`;\n                }\n            }\n        }\n        if (joined === undefined) {\n            return '.';\n        }\n        // Make sure that the joined path doesn't start with two slashes, because\n        // normalize() will mistake it for a UNC path then.\n        //\n        // This step is skipped when it is very clear that the user actually\n        // intended to point at a UNC path. This is assumed when the first\n        // non-empty string arguments starts with exactly two slashes followed by\n        // at least one more non-slash character.\n        //\n        // Note that for normalize() to treat a path as a UNC path it needs to\n        // have at least 2 components, so we don't filter for that here.\n        // This means that the user can use join to construct UNC paths from\n        // a server name and a share name; for example:\n        //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n        let needsReplace = true;\n        let slashCount = 0;\n        if (typeof firstPart === 'string' && isPathSeparator(firstPart.charCodeAt(0))) {\n            ++slashCount;\n            const firstLen = firstPart.length;\n            if (firstLen > 1 && isPathSeparator(firstPart.charCodeAt(1))) {\n                ++slashCount;\n                if (firstLen > 2) {\n                    if (isPathSeparator(firstPart.charCodeAt(2))) {\n                        ++slashCount;\n                    }\n                    else {\n                        // We matched a UNC path in the first part\n                        needsReplace = false;\n                    }\n                }\n            }\n        }\n        if (needsReplace) {\n            // Find any more consecutive slashes we need to replace\n            while (slashCount < joined.length &&\n                isPathSeparator(joined.charCodeAt(slashCount))) {\n                slashCount++;\n            }\n            // Replace the slashes if needed\n            if (slashCount >= 2) {\n                joined = `\\\\${joined.slice(slashCount)}`;\n            }\n        }\n        return win32.normalize(joined);\n    },\n    // It will solve the relative path from `from` to `to`, for instance:\n    //  from = 'C:\\\\orandea\\\\test\\\\aaa'\n    //  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n    // The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n    relative(from, to) {\n        validateString(from, 'from');\n        validateString(to, 'to');\n        if (from === to) {\n            return '';\n        }\n        const fromOrig = win32.resolve(from);\n        const toOrig = win32.resolve(to);\n        if (fromOrig === toOrig) {\n            return '';\n        }\n        from = fromOrig.toLowerCase();\n        to = toOrig.toLowerCase();\n        if (from === to) {\n            return '';\n        }\n        // Trim any leading backslashes\n        let fromStart = 0;\n        while (fromStart < from.length &&\n            from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {\n            fromStart++;\n        }\n        // Trim trailing backslashes (applicable to UNC paths only)\n        let fromEnd = from.length;\n        while (fromEnd - 1 > fromStart &&\n            from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {\n            fromEnd--;\n        }\n        const fromLen = fromEnd - fromStart;\n        // Trim any leading backslashes\n        let toStart = 0;\n        while (toStart < to.length &&\n            to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n            toStart++;\n        }\n        // Trim trailing backslashes (applicable to UNC paths only)\n        let toEnd = to.length;\n        while (toEnd - 1 > toStart &&\n            to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {\n            toEnd--;\n        }\n        const toLen = toEnd - toStart;\n        // Compare paths to find the longest common path from root\n        const length = fromLen < toLen ? fromLen : toLen;\n        let lastCommonSep = -1;\n        let i = 0;\n        for (; i < length; i++) {\n            const fromCode = from.charCodeAt(fromStart + i);\n            if (fromCode !== to.charCodeAt(toStart + i)) {\n                break;\n            }\n            else if (fromCode === CHAR_BACKWARD_SLASH) {\n                lastCommonSep = i;\n            }\n        }\n        // We found a mismatch before the first common path separator was seen, so\n        // return the original `to`.\n        if (i !== length) {\n            if (lastCommonSep === -1) {\n                return toOrig;\n            }\n        }\n        else {\n            if (toLen > length) {\n                if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n                    // We get here if `from` is the exact base path for `to`.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n                    return toOrig.slice(toStart + i + 1);\n                }\n                if (i === 2) {\n                    // We get here if `from` is the device root.\n                    // For example: from='C:\\\\'; to='C:\\\\foo'\n                    return toOrig.slice(toStart + i);\n                }\n            }\n            if (fromLen > length) {\n                if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n                    // We get here if `to` is the exact base path for `from`.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n                    lastCommonSep = i;\n                }\n                else if (i === 2) {\n                    // We get here if `to` is the device root.\n                    // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n                    lastCommonSep = 3;\n                }\n            }\n            if (lastCommonSep === -1) {\n                lastCommonSep = 0;\n            }\n        }\n        let out = '';\n        // Generate the relative path based on the path difference between `to` and\n        // `from`\n        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n            if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n                out += out.length === 0 ? '..' : '\\\\..';\n            }\n        }\n        toStart += lastCommonSep;\n        // Lastly, append the rest of the destination (`to`) path that comes after\n        // the common path parts\n        if (out.length > 0) {\n            return `${out}${toOrig.slice(toStart, toEnd)}`;\n        }\n        if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {\n            ++toStart;\n        }\n        return toOrig.slice(toStart, toEnd);\n    },\n    toNamespacedPath(path) {\n        // Note: this will *probably* throw somewhere.\n        if (typeof path !== 'string') {\n            return path;\n        }\n        if (path.length === 0) {\n            return '';\n        }\n        const resolvedPath = win32.resolve(path);\n        if (resolvedPath.length <= 2) {\n            return path;\n        }\n        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n            // Possible UNC root\n            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n                const code = resolvedPath.charCodeAt(2);\n                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n                    // Matched non-long UNC root, convert the path to a long UNC path\n                    return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n                }\n            }\n        }\n        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) &&\n            resolvedPath.charCodeAt(1) === CHAR_COLON &&\n            resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {\n            // Matched device root, convert the path to a long UNC path\n            return `\\\\\\\\?\\\\${resolvedPath}`;\n        }\n        return path;\n    },\n    dirname(path) {\n        validateString(path, 'path');\n        const len = path.length;\n        if (len === 0) {\n            return '.';\n        }\n        let rootEnd = -1;\n        let offset = 0;\n        const code = path.charCodeAt(0);\n        if (len === 1) {\n            // `path` contains just a path separator, exit early to avoid\n            // unnecessary work or a dot.\n            return isPathSeparator(code) ? path : '.';\n        }\n        // Try to match a root\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            rootEnd = offset = 1;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            return path;\n                        }\n                        if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            // Offset by 1 to include the separator after the UNC root to\n                            // treat it as a \"normal root\" on top of a (UNC) root\n                            rootEnd = offset = j + 1;\n                        }\n                    }\n                }\n            }\n            // Possible device root\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            rootEnd = len > 2 && isPathSeparator(path.charCodeAt(2)) ? 3 : 2;\n            offset = rootEnd;\n        }\n        let end = -1;\n        let matchedSlash = true;\n        for (let i = len - 1; i >= offset; --i) {\n            if (isPathSeparator(path.charCodeAt(i))) {\n                if (!matchedSlash) {\n                    end = i;\n                    break;\n                }\n            }\n            else {\n                // We saw the first non-path separator\n                matchedSlash = false;\n            }\n        }\n        if (end === -1) {\n            if (rootEnd === -1) {\n                return '.';\n            }\n            end = rootEnd;\n        }\n        return path.slice(0, end);\n    },\n    basename(path, ext) {\n        if (ext !== undefined) {\n            validateString(ext, 'ext');\n        }\n        validateString(path, 'path');\n        let start = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i;\n        // Check for a drive letter prefix so as not to mistake the following\n        // path separator as an extra separator at the end of the path that can be\n        // disregarded\n        if (path.length >= 2 &&\n            isWindowsDeviceRoot(path.charCodeAt(0)) &&\n            path.charCodeAt(1) === CHAR_COLON) {\n            start = 2;\n        }\n        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n            if (ext === path) {\n                return '';\n            }\n            let extIdx = ext.length - 1;\n            let firstNonSlashEnd = -1;\n            for (i = path.length - 1; i >= start; --i) {\n                const code = path.charCodeAt(i);\n                if (isPathSeparator(code)) {\n                    // If we reached a path separator that was not part of a set of path\n                    // separators at the end of the string, stop now\n                    if (!matchedSlash) {\n                        start = i + 1;\n                        break;\n                    }\n                }\n                else {\n                    if (firstNonSlashEnd === -1) {\n                        // We saw the first non-path separator, remember this index in case\n                        // we need it if the extension ends up not matching\n                        matchedSlash = false;\n                        firstNonSlashEnd = i + 1;\n                    }\n                    if (extIdx >= 0) {\n                        // Try to match the explicit extension\n                        if (code === ext.charCodeAt(extIdx)) {\n                            if (--extIdx === -1) {\n                                // We matched the extension, so mark this as the end of our path\n                                // component\n                                end = i;\n                            }\n                        }\n                        else {\n                            // Extension does not match, so our result is the entire path\n                            // component\n                            extIdx = -1;\n                            end = firstNonSlashEnd;\n                        }\n                    }\n                }\n            }\n            if (start === end) {\n                end = firstNonSlashEnd;\n            }\n            else if (end === -1) {\n                end = path.length;\n            }\n            return path.slice(start, end);\n        }\n        for (i = path.length - 1; i >= start; --i) {\n            if (isPathSeparator(path.charCodeAt(i))) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    start = i + 1;\n                    break;\n                }\n            }\n            else if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // path component\n                matchedSlash = false;\n                end = i + 1;\n            }\n        }\n        if (end === -1) {\n            return '';\n        }\n        return path.slice(start, end);\n    },\n    extname(path) {\n        validateString(path, 'path');\n        let start = 0;\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        // Check for a drive letter prefix so as not to mistake the following\n        // path separator as an extra separator at the end of the path that can be\n        // disregarded\n        if (path.length >= 2 &&\n            path.charCodeAt(1) === CHAR_COLON &&\n            isWindowsDeviceRoot(path.charCodeAt(0))) {\n            start = startPart = 2;\n        }\n        for (let i = path.length - 1; i >= start; --i) {\n            const code = path.charCodeAt(i);\n            if (isPathSeparator(code)) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\n            else if (startDot !== -1) {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n        if (startDot === -1 ||\n            end === -1 ||\n            // We saw a non-dot character immediately before the dot\n            preDotState === 0 ||\n            // The (right-most) trimmed path component is exactly '..'\n            (preDotState === 1 &&\n                startDot === end - 1 &&\n                startDot === startPart + 1)) {\n            return '';\n        }\n        return path.slice(startDot, end);\n    },\n    format: _format.bind(null, '\\\\'),\n    parse(path) {\n        validateString(path, 'path');\n        const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n        if (path.length === 0) {\n            return ret;\n        }\n        const len = path.length;\n        let rootEnd = 0;\n        let code = path.charCodeAt(0);\n        if (len === 1) {\n            if (isPathSeparator(code)) {\n                // `path` contains just a path separator, exit early to avoid\n                // unnecessary work\n                ret.root = ret.dir = path;\n                return ret;\n            }\n            ret.base = ret.name = path;\n            return ret;\n        }\n        // Try to match a root\n        if (isPathSeparator(code)) {\n            // Possible UNC root\n            rootEnd = 1;\n            if (isPathSeparator(path.charCodeAt(1))) {\n                // Matched double path separator at beginning\n                let j = 2;\n                let last = j;\n                // Match 1 or more non-path separators\n                while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                    j++;\n                }\n                if (j < len && j !== last) {\n                    // Matched!\n                    last = j;\n                    // Match 1 or more path separators\n                    while (j < len && isPathSeparator(path.charCodeAt(j))) {\n                        j++;\n                    }\n                    if (j < len && j !== last) {\n                        // Matched!\n                        last = j;\n                        // Match 1 or more non-path separators\n                        while (j < len && !isPathSeparator(path.charCodeAt(j))) {\n                            j++;\n                        }\n                        if (j === len) {\n                            // We matched a UNC root only\n                            rootEnd = j;\n                        }\n                        else if (j !== last) {\n                            // We matched a UNC root with leftovers\n                            rootEnd = j + 1;\n                        }\n                    }\n                }\n            }\n        }\n        else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {\n            // Possible device root\n            if (len <= 2) {\n                // `path` contains just a drive root, exit early to avoid\n                // unnecessary work\n                ret.root = ret.dir = path;\n                return ret;\n            }\n            rootEnd = 2;\n            if (isPathSeparator(path.charCodeAt(2))) {\n                if (len === 3) {\n                    // `path` contains just a drive root, exit early to avoid\n                    // unnecessary work\n                    ret.root = ret.dir = path;\n                    return ret;\n                }\n                rootEnd = 3;\n            }\n        }\n        if (rootEnd > 0) {\n            ret.root = path.slice(0, rootEnd);\n        }\n        let startDot = -1;\n        let startPart = rootEnd;\n        let end = -1;\n        let matchedSlash = true;\n        let i = path.length - 1;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        // Get non-dir info\n        for (; i >= rootEnd; --i) {\n            code = path.charCodeAt(i);\n            if (isPathSeparator(code)) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\n            else if (startDot !== -1) {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n        if (end !== -1) {\n            if (startDot === -1 ||\n                // We saw a non-dot character immediately before the dot\n                preDotState === 0 ||\n                // The (right-most) trimmed path component is exactly '..'\n                (preDotState === 1 &&\n                    startDot === end - 1 &&\n                    startDot === startPart + 1)) {\n                ret.base = ret.name = path.slice(startPart, end);\n            }\n            else {\n                ret.name = path.slice(startPart, startDot);\n                ret.base = path.slice(startPart, end);\n                ret.ext = path.slice(startDot, end);\n            }\n        }\n        // If the directory is the root, use the entire root as the `dir` including\n        // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n        // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n        if (startPart > 0 && startPart !== rootEnd) {\n            ret.dir = path.slice(0, startPart - 1);\n        }\n        else {\n            ret.dir = ret.root;\n        }\n        return ret;\n    },\n    sep: '\\\\',\n    delimiter: ';',\n    win32: null,\n    posix: null\n};\nexport const posix = {\n    // path.resolve([from ...], to)\n    resolve(...pathSegments) {\n        let resolvedPath = '';\n        let resolvedAbsolute = false;\n        for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n            const path = i >= 0 ? pathSegments[i] : process.cwd();\n            validateString(path, 'path');\n            // Skip empty entries\n            if (path.length === 0) {\n                continue;\n            }\n            resolvedPath = `${path}/${resolvedPath}`;\n            resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        }\n        // At this point the path should be resolved to a full absolute path, but\n        // handle relative paths to be safe (might happen when process.cwd() fails)\n        // Normalize the path\n        resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, '/', isPosixPathSeparator);\n        if (resolvedAbsolute) {\n            return `/${resolvedPath}`;\n        }\n        return resolvedPath.length > 0 ? resolvedPath : '.';\n    },\n    normalize(path) {\n        validateString(path, 'path');\n        if (path.length === 0) {\n            return '.';\n        }\n        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n        // Normalize the path\n        path = normalizeString(path, !isAbsolute, '/', isPosixPathSeparator);\n        if (path.length === 0) {\n            if (isAbsolute) {\n                return '/';\n            }\n            return trailingSeparator ? './' : '.';\n        }\n        if (trailingSeparator) {\n            path += '/';\n        }\n        return isAbsolute ? `/${path}` : path;\n    },\n    isAbsolute(path) {\n        validateString(path, 'path');\n        return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n    },\n    join(...paths) {\n        if (paths.length === 0) {\n            return '.';\n        }\n        let joined;\n        for (let i = 0; i < paths.length; ++i) {\n            const arg = paths[i];\n            validateString(arg, 'path');\n            if (arg.length > 0) {\n                if (joined === undefined) {\n                    joined = arg;\n                }\n                else {\n                    joined += `/${arg}`;\n                }\n            }\n        }\n        if (joined === undefined) {\n            return '.';\n        }\n        return posix.normalize(joined);\n    },\n    relative(from, to) {\n        validateString(from, 'from');\n        validateString(to, 'to');\n        if (from === to) {\n            return '';\n        }\n        // Trim leading forward slashes.\n        from = posix.resolve(from);\n        to = posix.resolve(to);\n        if (from === to) {\n            return '';\n        }\n        const fromStart = 1;\n        const fromEnd = from.length;\n        const fromLen = fromEnd - fromStart;\n        const toStart = 1;\n        const toLen = to.length - toStart;\n        // Compare paths to find the longest common path from root\n        const length = (fromLen < toLen ? fromLen : toLen);\n        let lastCommonSep = -1;\n        let i = 0;\n        for (; i < length; i++) {\n            const fromCode = from.charCodeAt(fromStart + i);\n            if (fromCode !== to.charCodeAt(toStart + i)) {\n                break;\n            }\n            else if (fromCode === CHAR_FORWARD_SLASH) {\n                lastCommonSep = i;\n            }\n        }\n        if (i === length) {\n            if (toLen > length) {\n                if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n                    // We get here if `from` is the exact base path for `to`.\n                    // For example: from='/foo/bar'; to='/foo/bar/baz'\n                    return to.slice(toStart + i + 1);\n                }\n                if (i === 0) {\n                    // We get here if `from` is the root\n                    // For example: from='/'; to='/foo'\n                    return to.slice(toStart + i);\n                }\n            }\n            else if (fromLen > length) {\n                if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n                    // We get here if `to` is the exact base path for `from`.\n                    // For example: from='/foo/bar/baz'; to='/foo/bar'\n                    lastCommonSep = i;\n                }\n                else if (i === 0) {\n                    // We get here if `to` is the root.\n                    // For example: from='/foo/bar'; to='/'\n                    lastCommonSep = 0;\n                }\n            }\n        }\n        let out = '';\n        // Generate the relative path based on the path difference between `to`\n        // and `from`.\n        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n            if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n                out += out.length === 0 ? '..' : '/..';\n            }\n        }\n        // Lastly, append the rest of the destination (`to`) path that comes after\n        // the common path parts.\n        return `${out}${to.slice(toStart + lastCommonSep)}`;\n    },\n    toNamespacedPath(path) {\n        // Non-op on posix systems\n        return path;\n    },\n    dirname(path) {\n        validateString(path, 'path');\n        if (path.length === 0) {\n            return '.';\n        }\n        const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        let end = -1;\n        let matchedSlash = true;\n        for (let i = path.length - 1; i >= 1; --i) {\n            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n                if (!matchedSlash) {\n                    end = i;\n                    break;\n                }\n            }\n            else {\n                // We saw the first non-path separator\n                matchedSlash = false;\n            }\n        }\n        if (end === -1) {\n            return hasRoot ? '/' : '.';\n        }\n        if (hasRoot && end === 1) {\n            return '//';\n        }\n        return path.slice(0, end);\n    },\n    basename(path, ext) {\n        if (ext !== undefined) {\n            validateString(ext, 'ext');\n        }\n        validateString(path, 'path');\n        let start = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i;\n        if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n            if (ext === path) {\n                return '';\n            }\n            let extIdx = ext.length - 1;\n            let firstNonSlashEnd = -1;\n            for (i = path.length - 1; i >= 0; --i) {\n                const code = path.charCodeAt(i);\n                if (code === CHAR_FORWARD_SLASH) {\n                    // If we reached a path separator that was not part of a set of path\n                    // separators at the end of the string, stop now\n                    if (!matchedSlash) {\n                        start = i + 1;\n                        break;\n                    }\n                }\n                else {\n                    if (firstNonSlashEnd === -1) {\n                        // We saw the first non-path separator, remember this index in case\n                        // we need it if the extension ends up not matching\n                        matchedSlash = false;\n                        firstNonSlashEnd = i + 1;\n                    }\n                    if (extIdx >= 0) {\n                        // Try to match the explicit extension\n                        if (code === ext.charCodeAt(extIdx)) {\n                            if (--extIdx === -1) {\n                                // We matched the extension, so mark this as the end of our path\n                                // component\n                                end = i;\n                            }\n                        }\n                        else {\n                            // Extension does not match, so our result is the entire path\n                            // component\n                            extIdx = -1;\n                            end = firstNonSlashEnd;\n                        }\n                    }\n                }\n            }\n            if (start === end) {\n                end = firstNonSlashEnd;\n            }\n            else if (end === -1) {\n                end = path.length;\n            }\n            return path.slice(start, end);\n        }\n        for (i = path.length - 1; i >= 0; --i) {\n            if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    start = i + 1;\n                    break;\n                }\n            }\n            else if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // path component\n                matchedSlash = false;\n                end = i + 1;\n            }\n        }\n        if (end === -1) {\n            return '';\n        }\n        return path.slice(start, end);\n    },\n    extname(path) {\n        validateString(path, 'path');\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        for (let i = path.length - 1; i >= 0; --i) {\n            const code = path.charCodeAt(i);\n            if (code === CHAR_FORWARD_SLASH) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\n            else if (startDot !== -1) {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n        if (startDot === -1 ||\n            end === -1 ||\n            // We saw a non-dot character immediately before the dot\n            preDotState === 0 ||\n            // The (right-most) trimmed path component is exactly '..'\n            (preDotState === 1 &&\n                startDot === end - 1 &&\n                startDot === startPart + 1)) {\n            return '';\n        }\n        return path.slice(startDot, end);\n    },\n    format: _format.bind(null, '/'),\n    parse(path) {\n        validateString(path, 'path');\n        const ret = { root: '', dir: '', base: '', ext: '', name: '' };\n        if (path.length === 0) {\n            return ret;\n        }\n        const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n        let start;\n        if (isAbsolute) {\n            ret.root = '/';\n            start = 1;\n        }\n        else {\n            start = 0;\n        }\n        let startDot = -1;\n        let startPart = 0;\n        let end = -1;\n        let matchedSlash = true;\n        let i = path.length - 1;\n        // Track the state of characters (if any) we see before our first dot and\n        // after any path separator we find\n        let preDotState = 0;\n        // Get non-dir info\n        for (; i >= start; --i) {\n            const code = path.charCodeAt(i);\n            if (code === CHAR_FORWARD_SLASH) {\n                // If we reached a path separator that was not part of a set of path\n                // separators at the end of the string, stop now\n                if (!matchedSlash) {\n                    startPart = i + 1;\n                    break;\n                }\n                continue;\n            }\n            if (end === -1) {\n                // We saw the first non-path separator, mark this as the end of our\n                // extension\n                matchedSlash = false;\n                end = i + 1;\n            }\n            if (code === CHAR_DOT) {\n                // If this is our first dot, mark it as the start of our extension\n                if (startDot === -1) {\n                    startDot = i;\n                }\n                else if (preDotState !== 1) {\n                    preDotState = 1;\n                }\n            }\n            else if (startDot !== -1) {\n                // We saw a non-dot and non-path separator before our dot, so we should\n                // have a good chance at having a non-empty extension\n                preDotState = -1;\n            }\n        }\n        if (end !== -1) {\n            const start = startPart === 0 && isAbsolute ? 1 : startPart;\n            if (startDot === -1 ||\n                // We saw a non-dot character immediately before the dot\n                preDotState === 0 ||\n                // The (right-most) trimmed path component is exactly '..'\n                (preDotState === 1 &&\n                    startDot === end - 1 &&\n                    startDot === startPart + 1)) {\n                ret.base = ret.name = path.slice(start, end);\n            }\n            else {\n                ret.name = path.slice(start, startDot);\n                ret.base = path.slice(start, end);\n                ret.ext = path.slice(startDot, end);\n            }\n        }\n        if (startPart > 0) {\n            ret.dir = path.slice(0, startPart - 1);\n        }\n        else if (isAbsolute) {\n            ret.dir = '/';\n        }\n        return ret;\n    },\n    sep: '/',\n    delimiter: ':',\n    win32: null,\n    posix: null\n};\nposix.win32 = win32.win32 = win32;\nposix.posix = win32.posix = posix;\nexport const normalize = (process.platform === 'win32' ? win32.normalize : posix.normalize);\nexport const resolve = (process.platform === 'win32' ? win32.resolve : posix.resolve);\nexport const relative = (process.platform === 'win32' ? win32.relative : posix.relative);\nexport const dirname = (process.platform === 'win32' ? win32.dirname : posix.dirname);\nexport const basename = (process.platform === 'win32' ? win32.basename : posix.basename);\nexport const extname = (process.platform === 'win32' ? win32.extname : posix.extname);\nexport const sep = (process.platform === 'win32' ? win32.sep : posix.sep);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as paths from './path.js';\nimport { isWindows } from './platform.js';\nconst _schemePattern = /^\\w[\\w\\d+.-]*$/;\nconst _singleSlashStart = /^\\//;\nconst _doubleSlashStart = /^\\/\\//;\nfunction _validateUri(ret, _strict) {\n    // scheme, must be set\n    if (!ret.scheme && _strict) {\n        throw new Error(`[UriError]: Scheme is missing: {scheme: \"\", authority: \"${ret.authority}\", path: \"${ret.path}\", query: \"${ret.query}\", fragment: \"${ret.fragment}\"}`);\n    }\n    // scheme, https://tools.ietf.org/html/rfc3986#section-3.1\n    // ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n    if (ret.scheme && !_schemePattern.test(ret.scheme)) {\n        throw new Error('[UriError]: Scheme contains illegal characters.');\n    }\n    // path, http://tools.ietf.org/html/rfc3986#section-3.3\n    // If a URI contains an authority component, then the path component\n    // must either be empty or begin with a slash (\"/\") character.  If a URI\n    // does not contain an authority component, then the path cannot begin\n    // with two slash characters (\"//\").\n    if (ret.path) {\n        if (ret.authority) {\n            if (!_singleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI contains an authority component, then the path component must either be empty or begin with a slash (\"/\") character');\n            }\n        }\n        else {\n            if (_doubleSlashStart.test(ret.path)) {\n                throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters (\"//\")');\n            }\n        }\n    }\n}\n// for a while we allowed uris *without* schemes and this is the migration\n// for them, e.g. an uri without scheme and without strict-mode warns and falls\n// back to the file-scheme. that should cause the least carnage and still be a\n// clear warning\nfunction _schemeFix(scheme, _strict) {\n    if (!scheme && !_strict) {\n        return 'file';\n    }\n    return scheme;\n}\n// implements a bit of https://tools.ietf.org/html/rfc3986#section-5\nfunction _referenceResolution(scheme, path) {\n    // the slash-character is our 'default base' as we don't\n    // support constructing URIs relative to other URIs. This\n    // also means that we alter and potentially break paths.\n    // see https://tools.ietf.org/html/rfc3986#section-5.1.4\n    switch (scheme) {\n        case 'https':\n        case 'http':\n        case 'file':\n            if (!path) {\n                path = _slash;\n            }\n            else if (path[0] !== _slash) {\n                path = _slash + path;\n            }\n            break;\n    }\n    return path;\n}\nconst _empty = '';\nconst _slash = '/';\nconst _regexp = /^(([^:/?#]+?):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?/;\n/**\n * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.\n * This class is a simple parser which creates the basic component parts\n * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation\n * and encoding.\n *\n * ```txt\n *       foo://example.com:8042/over/there?name=ferret#nose\n *       \\_/   \\______________/\\_________/ \\_________/ \\__/\n *        |           |            |            |        |\n *     scheme     authority       path        query   fragment\n *        |   _____________________|__\n *       / \\ /                        \\\n *       urn:example:animal:ferret:nose\n * ```\n */\nexport class URI {\n    /**\n     * @internal\n     */\n    constructor(schemeOrData, authority, path, query, fragment, _strict = false) {\n        if (typeof schemeOrData === 'object') {\n            this.scheme = schemeOrData.scheme || _empty;\n            this.authority = schemeOrData.authority || _empty;\n            this.path = schemeOrData.path || _empty;\n            this.query = schemeOrData.query || _empty;\n            this.fragment = schemeOrData.fragment || _empty;\n            // no validation because it's this URI\n            // that creates uri components.\n            // _validateUri(this);\n        }\n        else {\n            this.scheme = _schemeFix(schemeOrData, _strict);\n            this.authority = authority || _empty;\n            this.path = _referenceResolution(this.scheme, path || _empty);\n            this.query = query || _empty;\n            this.fragment = fragment || _empty;\n            _validateUri(this, _strict);\n        }\n    }\n    static isUri(thing) {\n        if (thing instanceof URI) {\n            return true;\n        }\n        if (!thing) {\n            return false;\n        }\n        return typeof thing.authority === 'string'\n            && typeof thing.fragment === 'string'\n            && typeof thing.path === 'string'\n            && typeof thing.query === 'string'\n            && typeof thing.scheme === 'string'\n            && typeof thing.fsPath === 'string'\n            && typeof thing.with === 'function'\n            && typeof thing.toString === 'function';\n    }\n    // ---- filesystem path -----------------------\n    /**\n     * Returns a string representing the corresponding file system path of this URI.\n     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the\n     * platform specific path separator.\n     *\n     * * Will *not* validate the path for invalid characters and semantics.\n     * * Will *not* look at the scheme of this URI.\n     * * The result shall *not* be used for display purposes but for accessing a file on disk.\n     *\n     *\n     * The *difference* to `URI#path` is the use of the platform specific separator and the handling\n     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).\n     *\n     * ```ts\n        const u = URI.parse('file://server/c$/folder/file.txt')\n        u.authority === 'server'\n        u.path === '/shares/c$/file.txt'\n        u.fsPath === '\\\\server\\c$\\folder\\file.txt'\n    ```\n     *\n     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,\n     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working\n     * with URIs that represent files on disk (`file` scheme).\n     */\n    get fsPath() {\n        // if (this.scheme !== 'file') {\n        // \tconsole.warn(`[UriError] calling fsPath with scheme ${this.scheme}`);\n        // }\n        return uriToFsPath(this, false);\n    }\n    // ---- modify to new -------------------------\n    with(change) {\n        if (!change) {\n            return this;\n        }\n        let { scheme, authority, path, query, fragment } = change;\n        if (scheme === undefined) {\n            scheme = this.scheme;\n        }\n        else if (scheme === null) {\n            scheme = _empty;\n        }\n        if (authority === undefined) {\n            authority = this.authority;\n        }\n        else if (authority === null) {\n            authority = _empty;\n        }\n        if (path === undefined) {\n            path = this.path;\n        }\n        else if (path === null) {\n            path = _empty;\n        }\n        if (query === undefined) {\n            query = this.query;\n        }\n        else if (query === null) {\n            query = _empty;\n        }\n        if (fragment === undefined) {\n            fragment = this.fragment;\n        }\n        else if (fragment === null) {\n            fragment = _empty;\n        }\n        if (scheme === this.scheme\n            && authority === this.authority\n            && path === this.path\n            && query === this.query\n            && fragment === this.fragment) {\n            return this;\n        }\n        return new Uri(scheme, authority, path, query, fragment);\n    }\n    // ---- parse & validate ------------------------\n    /**\n     * Creates a new URI from a string, e.g. `http://www.msft.com/some/path`,\n     * `file:///usr/home`, or `scheme:with/path`.\n     *\n     * @param value A string which represents an URI (see `URI#toString`).\n     */\n    static parse(value, _strict = false) {\n        const match = _regexp.exec(value);\n        if (!match) {\n            return new Uri(_empty, _empty, _empty, _empty, _empty);\n        }\n        return new Uri(match[2] || _empty, percentDecode(match[4] || _empty), percentDecode(match[5] || _empty), percentDecode(match[7] || _empty), percentDecode(match[9] || _empty), _strict);\n    }\n    /**\n     * Creates a new URI from a file system path, e.g. `c:\\my\\files`,\n     * `/usr/home`, or `\\\\server\\share\\some\\path`.\n     *\n     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument\n     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**\n     * `URI.parse('file://' + path)` because the path might contain characters that are\n     * interpreted (# and ?). See the following sample:\n     * ```ts\n    const good = URI.file('/coding/c#/project1');\n    good.scheme === 'file';\n    good.path === '/coding/c#/project1';\n    good.fragment === '';\n    const bad = URI.parse('file://' + '/coding/c#/project1');\n    bad.scheme === 'file';\n    bad.path === '/coding/c'; // path is now broken\n    bad.fragment === '/project1';\n    ```\n     *\n     * @param path A file system path (see `URI#fsPath`)\n     */\n    static file(path) {\n        let authority = _empty;\n        // normalize to fwd-slashes on windows,\n        // on other systems bwd-slashes are valid\n        // filename character, eg /f\\oo/ba\\r.txt\n        if (isWindows) {\n            path = path.replace(/\\\\/g, _slash);\n        }\n        // check for authority as used in UNC shares\n        // or use the path as given\n        if (path[0] === _slash && path[1] === _slash) {\n            const idx = path.indexOf(_slash, 2);\n            if (idx === -1) {\n                authority = path.substring(2);\n                path = _slash;\n            }\n            else {\n                authority = path.substring(2, idx);\n                path = path.substring(idx) || _slash;\n            }\n        }\n        return new Uri('file', authority, path, _empty, _empty);\n    }\n    static from(components) {\n        const result = new Uri(components.scheme, components.authority, components.path, components.query, components.fragment);\n        _validateUri(result, true);\n        return result;\n    }\n    /**\n     * Join a URI path with path fragments and normalizes the resulting path.\n     *\n     * @param uri The input URI.\n     * @param pathFragment The path fragment to add to the URI path.\n     * @returns The resulting URI.\n     */\n    static joinPath(uri, ...pathFragment) {\n        if (!uri.path) {\n            throw new Error(`[UriError]: cannot call joinPath on URI without path`);\n        }\n        let newPath;\n        if (isWindows && uri.scheme === 'file') {\n            newPath = URI.file(paths.win32.join(uriToFsPath(uri, true), ...pathFragment)).path;\n        }\n        else {\n            newPath = paths.posix.join(uri.path, ...pathFragment);\n        }\n        return uri.with({ path: newPath });\n    }\n    // ---- printing/externalize ---------------------------\n    /**\n     * Creates a string representation for this URI. It's guaranteed that calling\n     * `URI.parse` with the result of this function creates an URI which is equal\n     * to this URI.\n     *\n     * * The result shall *not* be used for display purposes but for externalization or transport.\n     * * The result will be encoded using the percentage encoding and encoding happens mostly\n     * ignore the scheme-specific encoding rules.\n     *\n     * @param skipEncoding Do not encode the result, default is `false`\n     */\n    toString(skipEncoding = false) {\n        return _asFormatted(this, skipEncoding);\n    }\n    toJSON() {\n        return this;\n    }\n    static revive(data) {\n        if (!data) {\n            return data;\n        }\n        else if (data instanceof URI) {\n            return data;\n        }\n        else {\n            const result = new Uri(data);\n            result._formatted = data.external;\n            result._fsPath = data._sep === _pathSepMarker ? data.fsPath : null;\n            return result;\n        }\n    }\n}\nconst _pathSepMarker = isWindows ? 1 : undefined;\n// This class exists so that URI is compatible with vscode.Uri (API).\nclass Uri extends URI {\n    constructor() {\n        super(...arguments);\n        this._formatted = null;\n        this._fsPath = null;\n    }\n    get fsPath() {\n        if (!this._fsPath) {\n            this._fsPath = uriToFsPath(this, false);\n        }\n        return this._fsPath;\n    }\n    toString(skipEncoding = false) {\n        if (!skipEncoding) {\n            if (!this._formatted) {\n                this._formatted = _asFormatted(this, false);\n            }\n            return this._formatted;\n        }\n        else {\n            // we don't cache that\n            return _asFormatted(this, true);\n        }\n    }\n    toJSON() {\n        const res = {\n            $mid: 1 /* Uri */\n        };\n        // cached state\n        if (this._fsPath) {\n            res.fsPath = this._fsPath;\n            res._sep = _pathSepMarker;\n        }\n        if (this._formatted) {\n            res.external = this._formatted;\n        }\n        // uri components\n        if (this.path) {\n            res.path = this.path;\n        }\n        if (this.scheme) {\n            res.scheme = this.scheme;\n        }\n        if (this.authority) {\n            res.authority = this.authority;\n        }\n        if (this.query) {\n            res.query = this.query;\n        }\n        if (this.fragment) {\n            res.fragment = this.fragment;\n        }\n        return res;\n    }\n}\n// reserved characters: https://tools.ietf.org/html/rfc3986#section-2.2\nconst encodeTable = {\n    [58 /* Colon */]: '%3A',\n    [47 /* Slash */]: '%2F',\n    [63 /* QuestionMark */]: '%3F',\n    [35 /* Hash */]: '%23',\n    [91 /* OpenSquareBracket */]: '%5B',\n    [93 /* CloseSquareBracket */]: '%5D',\n    [64 /* AtSign */]: '%40',\n    [33 /* ExclamationMark */]: '%21',\n    [36 /* DollarSign */]: '%24',\n    [38 /* Ampersand */]: '%26',\n    [39 /* SingleQuote */]: '%27',\n    [40 /* OpenParen */]: '%28',\n    [41 /* CloseParen */]: '%29',\n    [42 /* Asterisk */]: '%2A',\n    [43 /* Plus */]: '%2B',\n    [44 /* Comma */]: '%2C',\n    [59 /* Semicolon */]: '%3B',\n    [61 /* Equals */]: '%3D',\n    [32 /* Space */]: '%20',\n};\nfunction encodeURIComponentFast(uriComponent, allowSlash) {\n    let res = undefined;\n    let nativeEncodePos = -1;\n    for (let pos = 0; pos < uriComponent.length; pos++) {\n        const code = uriComponent.charCodeAt(pos);\n        // unreserved characters: https://tools.ietf.org/html/rfc3986#section-2.3\n        if ((code >= 97 /* a */ && code <= 122 /* z */)\n            || (code >= 65 /* A */ && code <= 90 /* Z */)\n            || (code >= 48 /* Digit0 */ && code <= 57 /* Digit9 */)\n            || code === 45 /* Dash */\n            || code === 46 /* Period */\n            || code === 95 /* Underline */\n            || code === 126 /* Tilde */\n            || (allowSlash && code === 47 /* Slash */)) {\n            // check if we are delaying native encode\n            if (nativeEncodePos !== -1) {\n                res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                nativeEncodePos = -1;\n            }\n            // check if we write into a new string (by default we try to return the param)\n            if (res !== undefined) {\n                res += uriComponent.charAt(pos);\n            }\n        }\n        else {\n            // encoding needed, we need to allocate a new string\n            if (res === undefined) {\n                res = uriComponent.substr(0, pos);\n            }\n            // check with default table first\n            const escaped = encodeTable[code];\n            if (escaped !== undefined) {\n                // check if we are delaying native encode\n                if (nativeEncodePos !== -1) {\n                    res += encodeURIComponent(uriComponent.substring(nativeEncodePos, pos));\n                    nativeEncodePos = -1;\n                }\n                // append escaped variant to result\n                res += escaped;\n            }\n            else if (nativeEncodePos === -1) {\n                // use native encode only when needed\n                nativeEncodePos = pos;\n            }\n        }\n    }\n    if (nativeEncodePos !== -1) {\n        res += encodeURIComponent(uriComponent.substring(nativeEncodePos));\n    }\n    return res !== undefined ? res : uriComponent;\n}\nfunction encodeURIComponentMinimal(path) {\n    let res = undefined;\n    for (let pos = 0; pos < path.length; pos++) {\n        const code = path.charCodeAt(pos);\n        if (code === 35 /* Hash */ || code === 63 /* QuestionMark */) {\n            if (res === undefined) {\n                res = path.substr(0, pos);\n            }\n            res += encodeTable[code];\n        }\n        else {\n            if (res !== undefined) {\n                res += path[pos];\n            }\n        }\n    }\n    return res !== undefined ? res : path;\n}\n/**\n * Compute `fsPath` for the given uri\n */\nexport function uriToFsPath(uri, keepDriveLetterCasing) {\n    let value;\n    if (uri.authority && uri.path.length > 1 && uri.scheme === 'file') {\n        // unc path: file://shares/c$/far/boo\n        value = `//${uri.authority}${uri.path}`;\n    }\n    else if (uri.path.charCodeAt(0) === 47 /* Slash */\n        && (uri.path.charCodeAt(1) >= 65 /* A */ && uri.path.charCodeAt(1) <= 90 /* Z */ || uri.path.charCodeAt(1) >= 97 /* a */ && uri.path.charCodeAt(1) <= 122 /* z */)\n        && uri.path.charCodeAt(2) === 58 /* Colon */) {\n        if (!keepDriveLetterCasing) {\n            // windows drive letter: file:///c:/far/boo\n            value = uri.path[1].toLowerCase() + uri.path.substr(2);\n        }\n        else {\n            value = uri.path.substr(1);\n        }\n    }\n    else {\n        // other path\n        value = uri.path;\n    }\n    if (isWindows) {\n        value = value.replace(/\\//g, '\\\\');\n    }\n    return value;\n}\n/**\n * Create the external version of a uri\n */\nfunction _asFormatted(uri, skipEncoding) {\n    const encoder = !skipEncoding\n        ? encodeURIComponentFast\n        : encodeURIComponentMinimal;\n    let res = '';\n    let { scheme, authority, path, query, fragment } = uri;\n    if (scheme) {\n        res += scheme;\n        res += ':';\n    }\n    if (authority || scheme === 'file') {\n        res += _slash;\n        res += _slash;\n    }\n    if (authority) {\n        let idx = authority.indexOf('@');\n        if (idx !== -1) {\n            // <user>@<auth>\n            const userinfo = authority.substr(0, idx);\n            authority = authority.substr(idx + 1);\n            idx = userinfo.indexOf(':');\n            if (idx === -1) {\n                res += encoder(userinfo, false);\n            }\n            else {\n                // <user>:<pass>@<auth>\n                res += encoder(userinfo.substr(0, idx), false);\n                res += ':';\n                res += encoder(userinfo.substr(idx + 1), false);\n            }\n            res += '@';\n        }\n        authority = authority.toLowerCase();\n        idx = authority.indexOf(':');\n        if (idx === -1) {\n            res += encoder(authority, false);\n        }\n        else {\n            // <auth>:<port>\n            res += encoder(authority.substr(0, idx), false);\n            res += authority.substr(idx);\n        }\n    }\n    if (path) {\n        // lower-case windows drive letters in /C:/fff or C:/fff\n        if (path.length >= 3 && path.charCodeAt(0) === 47 /* Slash */ && path.charCodeAt(2) === 58 /* Colon */) {\n            const code = path.charCodeAt(1);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = `/${String.fromCharCode(code + 32)}:${path.substr(3)}`; // \"/c:\".length === 3\n            }\n        }\n        else if (path.length >= 2 && path.charCodeAt(1) === 58 /* Colon */) {\n            const code = path.charCodeAt(0);\n            if (code >= 65 /* A */ && code <= 90 /* Z */) {\n                path = `${String.fromCharCode(code + 32)}:${path.substr(2)}`; // \"/c:\".length === 3\n            }\n        }\n        // encode the rest of the path\n        res += encoder(path, true);\n    }\n    if (query) {\n        res += '?';\n        res += encoder(query, false);\n    }\n    if (fragment) {\n        res += '#';\n        res += !skipEncoding ? encodeURIComponentFast(fragment, false) : fragment;\n    }\n    return res;\n}\n// --- decode\nfunction decodeURIComponentGraceful(str) {\n    try {\n        return decodeURIComponent(str);\n    }\n    catch (_a) {\n        if (str.length > 3) {\n            return str.substr(0, 3) + decodeURIComponentGraceful(str.substr(3));\n        }\n        else {\n            return str;\n        }\n    }\n}\nconst _rEncodedAsHex = /(%[0-9A-Za-z][0-9A-Za-z])+/g;\nfunction percentDecode(str) {\n    if (!str.match(_rEncodedAsHex)) {\n        return str;\n    }\n    return str.replace(_rEncodedAsHex, (match) => decodeURIComponentGraceful(match));\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nexport class Position {\n    constructor(lineNumber, column) {\n        this.lineNumber = lineNumber;\n        this.column = column;\n    }\n    /**\n     * Create a new position from this position.\n     *\n     * @param newLineNumber new line number\n     * @param newColumn new column\n     */\n    with(newLineNumber = this.lineNumber, newColumn = this.column) {\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\n            return this;\n        }\n        else {\n            return new Position(newLineNumber, newColumn);\n        }\n    }\n    /**\n     * Derive a new position from this position.\n     *\n     * @param deltaLineNumber line number delta\n     * @param deltaColumn column delta\n     */\n    delta(deltaLineNumber = 0, deltaColumn = 0) {\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n    }\n    /**\n     * Test if this position equals other position\n     */\n    equals(other) {\n        return Position.equals(this, other);\n    }\n    /**\n     * Test if position `a` equals position `b`\n     */\n    static equals(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.lineNumber === b.lineNumber &&\n            a.column === b.column);\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be false.\n     */\n    isBefore(other) {\n        return Position.isBefore(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be false.\n     */\n    static isBefore(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column < b.column;\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be true.\n     */\n    isBeforeOrEqual(other) {\n        return Position.isBeforeOrEqual(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be true.\n     */\n    static isBeforeOrEqual(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column <= b.column;\n    }\n    /**\n     * A function that compares positions, useful for sorting\n     */\n    static compare(a, b) {\n        let aLineNumber = a.lineNumber | 0;\n        let bLineNumber = b.lineNumber | 0;\n        if (aLineNumber === bLineNumber) {\n            let aColumn = a.column | 0;\n            let bColumn = b.column | 0;\n            return aColumn - bColumn;\n        }\n        return aLineNumber - bLineNumber;\n    }\n    /**\n     * Clone this position.\n     */\n    clone() {\n        return new Position(this.lineNumber, this.column);\n    }\n    /**\n     * Convert to a human-readable representation.\n     */\n    toString() {\n        return '(' + this.lineNumber + ',' + this.column + ')';\n    }\n    // ---\n    /**\n     * Create a `Position` from an `IPosition`.\n     */\n    static lift(pos) {\n        return new Position(pos.lineNumber, pos.column);\n    }\n    /**\n     * Test if `obj` is an `IPosition`.\n     */\n    static isIPosition(obj) {\n        return (obj\n            && (typeof obj.lineNumber === 'number')\n            && (typeof obj.column === 'number'));\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nexport class Range {\n    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n            this.startLineNumber = endLineNumber;\n            this.startColumn = endColumn;\n            this.endLineNumber = startLineNumber;\n            this.endColumn = startColumn;\n        }\n        else {\n            this.startLineNumber = startLineNumber;\n            this.startColumn = startColumn;\n            this.endLineNumber = endLineNumber;\n            this.endColumn = endColumn;\n        }\n    }\n    /**\n     * Test if this range is empty.\n     */\n    isEmpty() {\n        return Range.isEmpty(this);\n    }\n    /**\n     * Test if `range` is empty.\n     */\n    static isEmpty(range) {\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n    }\n    /**\n     * Test if position is in this range. If the position is at the edges, will return true.\n     */\n    containsPosition(position) {\n        return Range.containsPosition(this, position);\n    }\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\n     */\n    static containsPosition(range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return false.\n     * @internal\n     */\n    static strictContainsPosition(range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if range is in this range. If the range is equal to this range, will return true.\n     */\n    containsRange(range) {\n        return Range.containsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n     */\n    static containsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.\n     */\n    strictContainsRange(range) {\n        return Range.strictContainsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.\n     */\n    static strictContainsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    plusRange(range) {\n        return Range.plusRange(this, range);\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    static plusRange(a, b) {\n        let startLineNumber;\n        let startColumn;\n        let endLineNumber;\n        let endColumn;\n        if (b.startLineNumber < a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = b.startColumn;\n        }\n        else if (b.startLineNumber === a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = Math.min(b.startColumn, a.startColumn);\n        }\n        else {\n            startLineNumber = a.startLineNumber;\n            startColumn = a.startColumn;\n        }\n        if (b.endLineNumber > a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = b.endColumn;\n        }\n        else if (b.endLineNumber === a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = Math.max(b.endColumn, a.endColumn);\n        }\n        else {\n            endLineNumber = a.endLineNumber;\n            endColumn = a.endColumn;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    intersectRanges(range) {\n        return Range.intersectRanges(this, range);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    static intersectRanges(a, b) {\n        let resultStartLineNumber = a.startLineNumber;\n        let resultStartColumn = a.startColumn;\n        let resultEndLineNumber = a.endLineNumber;\n        let resultEndColumn = a.endColumn;\n        let otherStartLineNumber = b.startLineNumber;\n        let otherStartColumn = b.startColumn;\n        let otherEndLineNumber = b.endLineNumber;\n        let otherEndColumn = b.endColumn;\n        if (resultStartLineNumber < otherStartLineNumber) {\n            resultStartLineNumber = otherStartLineNumber;\n            resultStartColumn = otherStartColumn;\n        }\n        else if (resultStartLineNumber === otherStartLineNumber) {\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n        }\n        if (resultEndLineNumber > otherEndLineNumber) {\n            resultEndLineNumber = otherEndLineNumber;\n            resultEndColumn = otherEndColumn;\n        }\n        else if (resultEndLineNumber === otherEndLineNumber) {\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n        }\n        // Check if selection is now empty\n        if (resultStartLineNumber > resultEndLineNumber) {\n            return null;\n        }\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n            return null;\n        }\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n    }\n    /**\n     * Test if this range equals other.\n     */\n    equalsRange(other) {\n        return Range.equalsRange(this, other);\n    }\n    /**\n     * Test if range `a` equals `b`.\n     */\n    static equalsRange(a, b) {\n        return (!!a &&\n            !!b &&\n            a.startLineNumber === b.startLineNumber &&\n            a.startColumn === b.startColumn &&\n            a.endLineNumber === b.endLineNumber &&\n            a.endColumn === b.endColumn);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    getEndPosition() {\n        return Range.getEndPosition(this);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    static getEndPosition(range) {\n        return new Position(range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    getStartPosition() {\n        return Range.getStartPosition(this);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    static getStartPosition(range) {\n        return new Position(range.startLineNumber, range.startColumn);\n    }\n    /**\n     * Transform to a user presentable string representation.\n     */\n    toString() {\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n    }\n    /**\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    collapseToStart() {\n        return Range.collapseToStart(this);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    static collapseToStart(range) {\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n    }\n    // ---\n    static fromPositions(start, end = start) {\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    static lift(range) {\n        if (!range) {\n            return null;\n        }\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Test if `obj` is an `IRange`.\n     */\n    static isIRange(obj) {\n        return (obj\n            && (typeof obj.startLineNumber === 'number')\n            && (typeof obj.startColumn === 'number')\n            && (typeof obj.endLineNumber === 'number')\n            && (typeof obj.endColumn === 'number'));\n    }\n    /**\n     * Test if the two ranges are touching in any way.\n     */\n    static areIntersectingOrTouching(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n     */\n    static areIntersecting(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the startPosition and then on the endPosition\n     */\n    static compareRangesUsingStarts(a, b) {\n        if (a && b) {\n            const aStartLineNumber = a.startLineNumber | 0;\n            const bStartLineNumber = b.startLineNumber | 0;\n            if (aStartLineNumber === bStartLineNumber) {\n                const aStartColumn = a.startColumn | 0;\n                const bStartColumn = b.startColumn | 0;\n                if (aStartColumn === bStartColumn) {\n                    const aEndLineNumber = a.endLineNumber | 0;\n                    const bEndLineNumber = b.endLineNumber | 0;\n                    if (aEndLineNumber === bEndLineNumber) {\n                        const aEndColumn = a.endColumn | 0;\n                        const bEndColumn = b.endColumn | 0;\n                        return aEndColumn - bEndColumn;\n                    }\n                    return aEndLineNumber - bEndLineNumber;\n                }\n                return aStartColumn - bStartColumn;\n            }\n            return aStartLineNumber - bStartLineNumber;\n        }\n        const aExists = (a ? 1 : 0);\n        const bExists = (b ? 1 : 0);\n        return aExists - bExists;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the endPosition and then on the startPosition\n     */\n    static compareRangesUsingEnds(a, b) {\n        if (a.endLineNumber === b.endLineNumber) {\n            if (a.endColumn === b.endColumn) {\n                if (a.startLineNumber === b.startLineNumber) {\n                    return a.startColumn - b.startColumn;\n                }\n                return a.startLineNumber - b.startLineNumber;\n            }\n            return a.endColumn - b.endColumn;\n        }\n        return a.endLineNumber - b.endLineNumber;\n    }\n    /**\n     * Test if the range spans multiple lines.\n     */\n    static spansMultipleLines(range) {\n        return range.endLineNumber > range.startLineNumber;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { LcsDiff } from '../../../base/common/diff/diff.js';\nimport * as strings from '../../../base/common/strings.js';\nconst MINIMUM_MATCHING_CHARACTER_LENGTH = 3;\nfunction computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate, pretty) {\n    const diffAlgo = new LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);\n    return diffAlgo.ComputeDiff(pretty);\n}\nclass LineSequence {\n    constructor(lines) {\n        const startColumns = [];\n        const endColumns = [];\n        for (let i = 0, length = lines.length; i < length; i++) {\n            startColumns[i] = getFirstNonBlankColumn(lines[i], 1);\n            endColumns[i] = getLastNonBlankColumn(lines[i], 1);\n        }\n        this.lines = lines;\n        this._startColumns = startColumns;\n        this._endColumns = endColumns;\n    }\n    getElements() {\n        const elements = [];\n        for (let i = 0, len = this.lines.length; i < len; i++) {\n            elements[i] = this.lines[i].substring(this._startColumns[i] - 1, this._endColumns[i] - 1);\n        }\n        return elements;\n    }\n    getStrictElement(index) {\n        return this.lines[index];\n    }\n    getStartLineNumber(i) {\n        return i + 1;\n    }\n    getEndLineNumber(i) {\n        return i + 1;\n    }\n    createCharSequence(shouldIgnoreTrimWhitespace, startIndex, endIndex) {\n        const charCodes = [];\n        const lineNumbers = [];\n        const columns = [];\n        let len = 0;\n        for (let index = startIndex; index <= endIndex; index++) {\n            const lineContent = this.lines[index];\n            const startColumn = (shouldIgnoreTrimWhitespace ? this._startColumns[index] : 1);\n            const endColumn = (shouldIgnoreTrimWhitespace ? this._endColumns[index] : lineContent.length + 1);\n            for (let col = startColumn; col < endColumn; col++) {\n                charCodes[len] = lineContent.charCodeAt(col - 1);\n                lineNumbers[len] = index + 1;\n                columns[len] = col;\n                len++;\n            }\n        }\n        return new CharSequence(charCodes, lineNumbers, columns);\n    }\n}\nclass CharSequence {\n    constructor(charCodes, lineNumbers, columns) {\n        this._charCodes = charCodes;\n        this._lineNumbers = lineNumbers;\n        this._columns = columns;\n    }\n    getElements() {\n        return this._charCodes;\n    }\n    getStartLineNumber(i) {\n        return this._lineNumbers[i];\n    }\n    getStartColumn(i) {\n        return this._columns[i];\n    }\n    getEndLineNumber(i) {\n        return this._lineNumbers[i];\n    }\n    getEndColumn(i) {\n        return this._columns[i] + 1;\n    }\n}\nclass CharChange {\n    constructor(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalStartColumn = originalStartColumn;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.originalEndColumn = originalEndColumn;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedStartColumn = modifiedStartColumn;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.modifiedEndColumn = modifiedEndColumn;\n    }\n    static createFromDiffChange(diffChange, originalCharSequence, modifiedCharSequence) {\n        let originalStartLineNumber;\n        let originalStartColumn;\n        let originalEndLineNumber;\n        let originalEndColumn;\n        let modifiedStartLineNumber;\n        let modifiedStartColumn;\n        let modifiedEndLineNumber;\n        let modifiedEndColumn;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = 0;\n            originalStartColumn = 0;\n            originalEndLineNumber = 0;\n            originalEndColumn = 0;\n        }\n        else {\n            originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);\n            originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);\n            originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n            originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = 0;\n            modifiedStartColumn = 0;\n            modifiedEndLineNumber = 0;\n            modifiedEndColumn = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        return new CharChange(originalStartLineNumber, originalStartColumn, originalEndLineNumber, originalEndColumn, modifiedStartLineNumber, modifiedStartColumn, modifiedEndLineNumber, modifiedEndColumn);\n    }\n}\nfunction postProcessCharChanges(rawChanges) {\n    if (rawChanges.length <= 1) {\n        return rawChanges;\n    }\n    const result = [rawChanges[0]];\n    let prevChange = result[0];\n    for (let i = 1, len = rawChanges.length; i < len; i++) {\n        const currChange = rawChanges[i];\n        const originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);\n        const modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);\n        // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true\n        const matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);\n        if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {\n            // Merge the current change into the previous one\n            prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;\n            prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;\n        }\n        else {\n            // Add the current change\n            result.push(currChange);\n            prevChange = currChange;\n        }\n    }\n    return result;\n}\nclass LineChange {\n    constructor(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges) {\n        this.originalStartLineNumber = originalStartLineNumber;\n        this.originalEndLineNumber = originalEndLineNumber;\n        this.modifiedStartLineNumber = modifiedStartLineNumber;\n        this.modifiedEndLineNumber = modifiedEndLineNumber;\n        this.charChanges = charChanges;\n    }\n    static createFromDiffResult(shouldIgnoreTrimWhitespace, diffChange, originalLineSequence, modifiedLineSequence, continueCharDiff, shouldComputeCharChanges, shouldPostProcessCharChanges) {\n        let originalStartLineNumber;\n        let originalEndLineNumber;\n        let modifiedStartLineNumber;\n        let modifiedEndLineNumber;\n        let charChanges = undefined;\n        if (diffChange.originalLength === 0) {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;\n            originalEndLineNumber = 0;\n        }\n        else {\n            originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);\n            originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);\n        }\n        if (diffChange.modifiedLength === 0) {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;\n            modifiedEndLineNumber = 0;\n        }\n        else {\n            modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);\n            modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);\n        }\n        if (shouldComputeCharChanges && diffChange.originalLength > 0 && diffChange.originalLength < 20 && diffChange.modifiedLength > 0 && diffChange.modifiedLength < 20 && continueCharDiff()) {\n            // Compute character changes for diff chunks of at most 20 lines...\n            const originalCharSequence = originalLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);\n            const modifiedCharSequence = modifiedLineSequence.createCharSequence(shouldIgnoreTrimWhitespace, diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);\n            let rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueCharDiff, true).changes;\n            if (shouldPostProcessCharChanges) {\n                rawChanges = postProcessCharChanges(rawChanges);\n            }\n            charChanges = [];\n            for (let i = 0, length = rawChanges.length; i < length; i++) {\n                charChanges.push(CharChange.createFromDiffChange(rawChanges[i], originalCharSequence, modifiedCharSequence));\n            }\n        }\n        return new LineChange(originalStartLineNumber, originalEndLineNumber, modifiedStartLineNumber, modifiedEndLineNumber, charChanges);\n    }\n}\nexport class DiffComputer {\n    constructor(originalLines, modifiedLines, opts) {\n        this.shouldComputeCharChanges = opts.shouldComputeCharChanges;\n        this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;\n        this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;\n        this.shouldMakePrettyDiff = opts.shouldMakePrettyDiff;\n        this.originalLines = originalLines;\n        this.modifiedLines = modifiedLines;\n        this.original = new LineSequence(originalLines);\n        this.modified = new LineSequence(modifiedLines);\n        this.continueLineDiff = createContinueProcessingPredicate(opts.maxComputationTime);\n        this.continueCharDiff = createContinueProcessingPredicate(opts.maxComputationTime === 0 ? 0 : Math.min(opts.maxComputationTime, 5000)); // never run after 5s for character changes...\n    }\n    computeDiff() {\n        if (this.original.lines.length === 1 && this.original.lines[0].length === 0) {\n            // empty original => fast path\n            if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n                return {\n                    quitEarly: false,\n                    changes: []\n                };\n            }\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: 1,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: this.modified.lines.length,\n                        charChanges: [{\n                                modifiedEndColumn: 0,\n                                modifiedEndLineNumber: 0,\n                                modifiedStartColumn: 0,\n                                modifiedStartLineNumber: 0,\n                                originalEndColumn: 0,\n                                originalEndLineNumber: 0,\n                                originalStartColumn: 0,\n                                originalStartLineNumber: 0\n                            }]\n                    }]\n            };\n        }\n        if (this.modified.lines.length === 1 && this.modified.lines[0].length === 0) {\n            // empty modified => fast path\n            return {\n                quitEarly: false,\n                changes: [{\n                        originalStartLineNumber: 1,\n                        originalEndLineNumber: this.original.lines.length,\n                        modifiedStartLineNumber: 1,\n                        modifiedEndLineNumber: 1,\n                        charChanges: [{\n                                modifiedEndColumn: 0,\n                                modifiedEndLineNumber: 0,\n                                modifiedStartColumn: 0,\n                                modifiedStartLineNumber: 0,\n                                originalEndColumn: 0,\n                                originalEndLineNumber: 0,\n                                originalStartColumn: 0,\n                                originalStartLineNumber: 0\n                            }]\n                    }]\n            };\n        }\n        const diffResult = computeDiff(this.original, this.modified, this.continueLineDiff, this.shouldMakePrettyDiff);\n        const rawChanges = diffResult.changes;\n        const quitEarly = diffResult.quitEarly;\n        // The diff is always computed with ignoring trim whitespace\n        // This ensures we get the prettiest diff\n        if (this.shouldIgnoreTrimWhitespace) {\n            const lineChanges = [];\n            for (let i = 0, length = rawChanges.length; i < length; i++) {\n                lineChanges.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, rawChanges[i], this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n            }\n            return {\n                quitEarly: quitEarly,\n                changes: lineChanges\n            };\n        }\n        // Need to post-process and introduce changes where the trim whitespace is different\n        // Note that we are looping starting at -1 to also cover the lines before the first change\n        const result = [];\n        let originalLineIndex = 0;\n        let modifiedLineIndex = 0;\n        for (let i = -1 /* !!!! */, len = rawChanges.length; i < len; i++) {\n            const nextChange = (i + 1 < len ? rawChanges[i + 1] : null);\n            const originalStop = (nextChange ? nextChange.originalStart : this.originalLines.length);\n            const modifiedStop = (nextChange ? nextChange.modifiedStart : this.modifiedLines.length);\n            while (originalLineIndex < originalStop && modifiedLineIndex < modifiedStop) {\n                const originalLine = this.originalLines[originalLineIndex];\n                const modifiedLine = this.modifiedLines[modifiedLineIndex];\n                if (originalLine !== modifiedLine) {\n                    // These lines differ only in trim whitespace\n                    // Check the leading whitespace\n                    {\n                        let originalStartColumn = getFirstNonBlankColumn(originalLine, 1);\n                        let modifiedStartColumn = getFirstNonBlankColumn(modifiedLine, 1);\n                        while (originalStartColumn > 1 && modifiedStartColumn > 1) {\n                            const originalChar = originalLine.charCodeAt(originalStartColumn - 2);\n                            const modifiedChar = modifiedLine.charCodeAt(modifiedStartColumn - 2);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalStartColumn--;\n                            modifiedStartColumn--;\n                        }\n                        if (originalStartColumn > 1 || modifiedStartColumn > 1) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, 1, originalStartColumn, modifiedLineIndex + 1, 1, modifiedStartColumn);\n                        }\n                    }\n                    // Check the trailing whitespace\n                    {\n                        let originalEndColumn = getLastNonBlankColumn(originalLine, 1);\n                        let modifiedEndColumn = getLastNonBlankColumn(modifiedLine, 1);\n                        const originalMaxColumn = originalLine.length + 1;\n                        const modifiedMaxColumn = modifiedLine.length + 1;\n                        while (originalEndColumn < originalMaxColumn && modifiedEndColumn < modifiedMaxColumn) {\n                            const originalChar = originalLine.charCodeAt(originalEndColumn - 1);\n                            const modifiedChar = originalLine.charCodeAt(modifiedEndColumn - 1);\n                            if (originalChar !== modifiedChar) {\n                                break;\n                            }\n                            originalEndColumn++;\n                            modifiedEndColumn++;\n                        }\n                        if (originalEndColumn < originalMaxColumn || modifiedEndColumn < modifiedMaxColumn) {\n                            this._pushTrimWhitespaceCharChange(result, originalLineIndex + 1, originalEndColumn, originalMaxColumn, modifiedLineIndex + 1, modifiedEndColumn, modifiedMaxColumn);\n                        }\n                    }\n                }\n                originalLineIndex++;\n                modifiedLineIndex++;\n            }\n            if (nextChange) {\n                // Emit the actual change\n                result.push(LineChange.createFromDiffResult(this.shouldIgnoreTrimWhitespace, nextChange, this.original, this.modified, this.continueCharDiff, this.shouldComputeCharChanges, this.shouldPostProcessCharChanges));\n                originalLineIndex += nextChange.originalLength;\n                modifiedLineIndex += nextChange.modifiedLength;\n            }\n        }\n        return {\n            quitEarly: quitEarly,\n            changes: result\n        };\n    }\n    _pushTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        if (this._mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn)) {\n            // Merged into previous\n            return;\n        }\n        let charChanges = undefined;\n        if (this.shouldComputeCharChanges) {\n            charChanges = [new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn)];\n        }\n        result.push(new LineChange(originalLineNumber, originalLineNumber, modifiedLineNumber, modifiedLineNumber, charChanges));\n    }\n    _mergeTrimWhitespaceCharChange(result, originalLineNumber, originalStartColumn, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedEndColumn) {\n        const len = result.length;\n        if (len === 0) {\n            return false;\n        }\n        const prevChange = result[len - 1];\n        if (prevChange.originalEndLineNumber === 0 || prevChange.modifiedEndLineNumber === 0) {\n            // Don't merge with inserts/deletes\n            return false;\n        }\n        if (prevChange.originalEndLineNumber + 1 === originalLineNumber && prevChange.modifiedEndLineNumber + 1 === modifiedLineNumber) {\n            prevChange.originalEndLineNumber = originalLineNumber;\n            prevChange.modifiedEndLineNumber = modifiedLineNumber;\n            if (this.shouldComputeCharChanges && prevChange.charChanges) {\n                prevChange.charChanges.push(new CharChange(originalLineNumber, originalStartColumn, originalLineNumber, originalEndColumn, modifiedLineNumber, modifiedStartColumn, modifiedLineNumber, modifiedEndColumn));\n            }\n            return true;\n        }\n        return false;\n    }\n}\nfunction getFirstNonBlankColumn(txt, defaultValue) {\n    const r = strings.firstNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 1;\n}\nfunction getLastNonBlankColumn(txt, defaultValue) {\n    const r = strings.lastNonWhitespaceIndex(txt);\n    if (r === -1) {\n        return defaultValue;\n    }\n    return r + 2;\n}\nfunction createContinueProcessingPredicate(maximumRuntime) {\n    if (maximumRuntime === 0) {\n        return () => true;\n    }\n    const startTime = Date.now();\n    return () => {\n        return Date.now() - startTime < maximumRuntime;\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function toUint8(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 255 /* MAX_UINT_8 */) {\n        return 255 /* MAX_UINT_8 */;\n    }\n    return v | 0;\n}\nexport function toUint32(v) {\n    if (v < 0) {\n        return 0;\n    }\n    if (v > 4294967295 /* MAX_UINT_32 */) {\n        return 4294967295 /* MAX_UINT_32 */;\n    }\n    return v | 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { arrayInsert } from '../../../base/common/arrays.js';\nimport { toUint32 } from '../../../base/common/uint.js';\nexport class PrefixSumComputer {\n    constructor(values) {\n        this.values = values;\n        this.prefixSum = new Uint32Array(values.length);\n        this.prefixSumValidIndex = new Int32Array(1);\n        this.prefixSumValidIndex[0] = -1;\n    }\n    insertValues(insertIndex, insertValues) {\n        insertIndex = toUint32(insertIndex);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        const insertValuesLen = insertValues.length;\n        if (insertValuesLen === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length + insertValuesLen);\n        this.values.set(oldValues.subarray(0, insertIndex), 0);\n        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);\n        this.values.set(insertValues, insertIndex);\n        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = insertIndex - 1;\n        }\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    setValue(index, value) {\n        index = toUint32(index);\n        value = toUint32(value);\n        if (this.values[index] === value) {\n            return false;\n        }\n        this.values[index] = value;\n        if (index - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = index - 1;\n        }\n        return true;\n    }\n    removeValues(startIndex, count) {\n        startIndex = toUint32(startIndex);\n        count = toUint32(count);\n        const oldValues = this.values;\n        const oldPrefixSum = this.prefixSum;\n        if (startIndex >= oldValues.length) {\n            return false;\n        }\n        let maxCount = oldValues.length - startIndex;\n        if (count >= maxCount) {\n            count = maxCount;\n        }\n        if (count === 0) {\n            return false;\n        }\n        this.values = new Uint32Array(oldValues.length - count);\n        this.values.set(oldValues.subarray(0, startIndex), 0);\n        this.values.set(oldValues.subarray(startIndex + count), startIndex);\n        this.prefixSum = new Uint32Array(this.values.length);\n        if (startIndex - 1 < this.prefixSumValidIndex[0]) {\n            this.prefixSumValidIndex[0] = startIndex - 1;\n        }\n        if (this.prefixSumValidIndex[0] >= 0) {\n            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));\n        }\n        return true;\n    }\n    getTotalSum() {\n        if (this.values.length === 0) {\n            return 0;\n        }\n        return this._getPrefixSum(this.values.length - 1);\n    }\n    /**\n     * Returns the sum of the first `index + 1` many items.\n     * @returns `SUM(0 <= j <= index, values[j])`.\n     */\n    getPrefixSum(index) {\n        if (index < 0) {\n            return 0;\n        }\n        index = toUint32(index);\n        return this._getPrefixSum(index);\n    }\n    _getPrefixSum(index) {\n        if (index <= this.prefixSumValidIndex[0]) {\n            return this.prefixSum[index];\n        }\n        let startIndex = this.prefixSumValidIndex[0] + 1;\n        if (startIndex === 0) {\n            this.prefixSum[0] = this.values[0];\n            startIndex++;\n        }\n        if (index >= this.values.length) {\n            index = this.values.length - 1;\n        }\n        for (let i = startIndex; i <= index; i++) {\n            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];\n        }\n        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);\n        return this.prefixSum[index];\n    }\n    getIndexOf(sum) {\n        sum = Math.floor(sum);\n        // Compute all sums (to get a fully valid prefixSum)\n        this.getTotalSum();\n        let low = 0;\n        let high = this.values.length - 1;\n        let mid = 0;\n        let midStop = 0;\n        let midStart = 0;\n        while (low <= high) {\n            mid = low + ((high - low) / 2) | 0;\n            midStop = this.prefixSum[mid];\n            midStart = midStop - this.values[mid];\n            if (sum < midStart) {\n                high = mid - 1;\n            }\n            else if (sum >= midStop) {\n                low = mid + 1;\n            }\n            else {\n                break;\n            }\n        }\n        return new PrefixSumIndexOfResult(mid, sum - midStart);\n    }\n}\n/**\n * {@link getIndexOf} has an amortized runtime complexity of O(1).\n *\n * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))\n*/\nexport class ConstantTimePrefixSumComputer {\n    constructor(values) {\n        this._values = values;\n        this._isValid = false;\n        this._validEndIndex = -1;\n        this._prefixSum = [];\n        this._indexBySum = [];\n    }\n    /**\n     * @returns SUM(0 <= j < values.length, values[j])\n     */\n    getTotalSum() {\n        this._ensureValid();\n        return this._indexBySum.length;\n    }\n    /**\n     * Returns the sum of the first `count` many items.\n     * @returns `SUM(0 <= j < count, values[j])`.\n     */\n    getPrefixSum(count) {\n        this._ensureValid();\n        if (count === 0) {\n            return 0;\n        }\n        return this._prefixSum[count - 1];\n    }\n    /**\n     * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`\n     */\n    getIndexOf(sum) {\n        this._ensureValid();\n        const idx = this._indexBySum[sum];\n        const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;\n        return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);\n    }\n    removeValues(start, deleteCount) {\n        this._values.splice(start, deleteCount);\n        this._invalidate(start);\n    }\n    insertValues(insertIndex, insertArr) {\n        this._values = arrayInsert(this._values, insertIndex, insertArr);\n        this._invalidate(insertIndex);\n    }\n    _invalidate(index) {\n        this._isValid = false;\n        this._validEndIndex = Math.min(this._validEndIndex, index - 1);\n    }\n    _ensureValid() {\n        if (this._isValid) {\n            return;\n        }\n        for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {\n            const value = this._values[i];\n            const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;\n            this._prefixSum[i] = sumAbove + value;\n            for (let j = 0; j < value; j++) {\n                this._indexBySum[sumAbove + j] = i;\n            }\n        }\n        // trim things\n        this._prefixSum.length = this._values.length;\n        this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];\n        // mark as valid\n        this._isValid = true;\n        this._validEndIndex = this._values.length - 1;\n    }\n    setValue(index, value) {\n        if (this._values[index] === value) {\n            // no change\n            return;\n        }\n        this._values[index] = value;\n        this._invalidate(index);\n    }\n}\nexport class PrefixSumIndexOfResult {\n    constructor(index, remainder) {\n        this.index = index;\n        this.remainder = remainder;\n        this._prefixSumIndexOfResultBrand = undefined;\n        this.index = index;\n        this.remainder = remainder;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords = '') {\n    let source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n    for (const sep of USUAL_WORD_SEPARATORS) {\n        if (allowInWords.indexOf(sep) >= 0) {\n            continue;\n        }\n        source += '\\\\' + sep;\n    }\n    source += '\\\\s]+)';\n    return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport const DEFAULT_WORD_REGEXP = createWordRegExp();\nexport function ensureValidWordDefinition(wordDefinition) {\n    let result = DEFAULT_WORD_REGEXP;\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\n        if (!wordDefinition.global) {\n            let flags = 'g';\n            if (wordDefinition.ignoreCase) {\n                flags += 'i';\n            }\n            if (wordDefinition.multiline) {\n                flags += 'm';\n            }\n            if (wordDefinition.unicode) {\n                flags += 'u';\n            }\n            result = new RegExp(wordDefinition.source, flags);\n        }\n        else {\n            result = wordDefinition;\n        }\n    }\n    result.lastIndex = 0;\n    return result;\n}\nconst _defaultConfig = {\n    maxLen: 1000,\n    windowSize: 15,\n    timeBudget: 150\n};\nexport function getWordAtText(column, wordDefinition, text, textOffset, config = _defaultConfig) {\n    if (text.length > config.maxLen) {\n        // don't throw strings that long at the regexp\n        // but use a sub-string in which a word must occur\n        let start = column - config.maxLen / 2;\n        if (start < 0) {\n            start = 0;\n        }\n        else {\n            textOffset += start;\n        }\n        text = text.substring(start, column + config.maxLen / 2);\n        return getWordAtText(column, wordDefinition, text, textOffset, config);\n    }\n    const t1 = Date.now();\n    const pos = column - 1 - textOffset;\n    let prevRegexIndex = -1;\n    let match = null;\n    for (let i = 1;; i++) {\n        // check time budget\n        if (Date.now() - t1 >= config.timeBudget) {\n            break;\n        }\n        // reset the index at which the regexp should start matching, also know where it\n        // should stop so that subsequent search don't repeat previous searches\n        const regexIndex = pos - config.windowSize * i;\n        wordDefinition.lastIndex = Math.max(0, regexIndex);\n        const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);\n        if (!thisMatch && match) {\n            // stop: we have something\n            break;\n        }\n        match = thisMatch;\n        // stop: searched at start\n        if (regexIndex <= 0) {\n            break;\n        }\n        prevRegexIndex = regexIndex;\n    }\n    if (match) {\n        let result = {\n            word: match[0],\n            startColumn: textOffset + 1 + match.index,\n            endColumn: textOffset + 1 + match.index + match[0].length\n        };\n        wordDefinition.lastIndex = 0;\n        return result;\n    }\n    return null;\n}\nfunction _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {\n    let match;\n    while (match = wordDefinition.exec(text)) {\n        const matchIndex = match.index || 0;\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n            return match;\n        }\n        else if (stopPos > 0 && matchIndex > stopPos) {\n            return null;\n        }\n    }\n    return null;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint8 } from '../../../base/common/uint.js';\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nexport class CharacterClassifier {\n    constructor(_defaultValue) {\n        let defaultValue = toUint8(_defaultValue);\n        this._defaultValue = defaultValue;\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n        this._map = new Map();\n    }\n    static _createAsciiMap(defaultValue) {\n        let asciiMap = new Uint8Array(256);\n        for (let i = 0; i < 256; i++) {\n            asciiMap[i] = defaultValue;\n        }\n        return asciiMap;\n    }\n    set(charCode, _value) {\n        let value = toUint8(_value);\n        if (charCode >= 0 && charCode < 256) {\n            this._asciiMap[charCode] = value;\n        }\n        else {\n            this._map.set(charCode, value);\n        }\n    }\n    get(charCode) {\n        if (charCode >= 0 && charCode < 256) {\n            return this._asciiMap[charCode];\n        }\n        else {\n            return (this._map.get(charCode) || this._defaultValue);\n        }\n    }\n}\nexport class CharacterSet {\n    constructor() {\n        this._actual = new CharacterClassifier(0 /* False */);\n    }\n    add(charCode) {\n        this._actual.set(charCode, 1 /* True */);\n    }\n    has(charCode) {\n        return (this._actual.get(charCode) === 1 /* True */);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nexport class Uint8Matrix {\n    constructor(rows, cols, defaultValue) {\n        const data = new Uint8Array(rows * cols);\n        for (let i = 0, len = rows * cols; i < len; i++) {\n            data[i] = defaultValue;\n        }\n        this._data = data;\n        this.rows = rows;\n        this.cols = cols;\n    }\n    get(row, col) {\n        return this._data[row * this.cols + col];\n    }\n    set(row, col, value) {\n        this._data[row * this.cols + col] = value;\n    }\n}\nexport class StateMachine {\n    constructor(edges) {\n        let maxCharCode = 0;\n        let maxState = 0 /* Invalid */;\n        for (let i = 0, len = edges.length; i < len; i++) {\n            let [from, chCode, to] = edges[i];\n            if (chCode > maxCharCode) {\n                maxCharCode = chCode;\n            }\n            if (from > maxState) {\n                maxState = from;\n            }\n            if (to > maxState) {\n                maxState = to;\n            }\n        }\n        maxCharCode++;\n        maxState++;\n        let states = new Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);\n        for (let i = 0, len = edges.length; i < len; i++) {\n            let [from, chCode, to] = edges[i];\n            states.set(from, chCode, to);\n        }\n        this._states = states;\n        this._maxCharCode = maxCharCode;\n    }\n    nextState(currentState, chCode) {\n        if (chCode < 0 || chCode >= this._maxCharCode) {\n            return 0 /* Invalid */;\n        }\n        return this._states.get(currentState, chCode);\n    }\n}\n// State machine for http:// or https:// or file://\nlet _stateMachine = null;\nfunction getStateMachine() {\n    if (_stateMachine === null) {\n        _stateMachine = new StateMachine([\n            [1 /* Start */, 104 /* h */, 2 /* H */],\n            [1 /* Start */, 72 /* H */, 2 /* H */],\n            [1 /* Start */, 102 /* f */, 6 /* F */],\n            [1 /* Start */, 70 /* F */, 6 /* F */],\n            [2 /* H */, 116 /* t */, 3 /* HT */],\n            [2 /* H */, 84 /* T */, 3 /* HT */],\n            [3 /* HT */, 116 /* t */, 4 /* HTT */],\n            [3 /* HT */, 84 /* T */, 4 /* HTT */],\n            [4 /* HTT */, 112 /* p */, 5 /* HTTP */],\n            [4 /* HTT */, 80 /* P */, 5 /* HTTP */],\n            [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],\n            [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],\n            [6 /* F */, 105 /* i */, 7 /* FI */],\n            [6 /* F */, 73 /* I */, 7 /* FI */],\n            [7 /* FI */, 108 /* l */, 8 /* FIL */],\n            [7 /* FI */, 76 /* L */, 8 /* FIL */],\n            [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],\n            [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],\n            [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],\n            [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],\n            [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],\n        ]);\n    }\n    return _stateMachine;\n}\nlet _classifier = null;\nfunction getClassifier() {\n    if (_classifier === null) {\n        _classifier = new CharacterClassifier(0 /* None */);\n        // allow-any-unicode-next-line\n        const FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';\n        for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);\n        }\n        const CANNOT_END_WITH_CHARACTERS = '.,;';\n        for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);\n        }\n    }\n    return _classifier;\n}\nexport class LinkComputer {\n    static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n        // Do not allow to end link in certain characters...\n        let lastIncludedCharIndex = linkEndIndex - 1;\n        do {\n            const chCode = line.charCodeAt(lastIncludedCharIndex);\n            const chClass = classifier.get(chCode);\n            if (chClass !== 2 /* CannotEndIn */) {\n                break;\n            }\n            lastIncludedCharIndex--;\n        } while (lastIncludedCharIndex > linkBeginIndex);\n        // Handle links enclosed in parens, square brackets and curlys.\n        if (linkBeginIndex > 0) {\n            const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n            const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n            if ((charCodeBeforeLink === 40 /* OpenParen */ && lastCharCodeInLink === 41 /* CloseParen */)\n                || (charCodeBeforeLink === 91 /* OpenSquareBracket */ && lastCharCodeInLink === 93 /* CloseSquareBracket */)\n                || (charCodeBeforeLink === 123 /* OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CloseCurlyBrace */)) {\n                // Do not end in ) if ( is before the link start\n                // Do not end in ] if [ is before the link start\n                // Do not end in } if { is before the link start\n                lastIncludedCharIndex--;\n            }\n        }\n        return {\n            range: {\n                startLineNumber: lineNumber,\n                startColumn: linkBeginIndex + 1,\n                endLineNumber: lineNumber,\n                endColumn: lastIncludedCharIndex + 2\n            },\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n        };\n    }\n    static computeLinks(model, stateMachine = getStateMachine()) {\n        const classifier = getClassifier();\n        let result = [];\n        for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n            const line = model.getLineContent(i);\n            const len = line.length;\n            let j = 0;\n            let linkBeginIndex = 0;\n            let linkBeginChCode = 0;\n            let state = 1 /* Start */;\n            let hasOpenParens = false;\n            let hasOpenSquareBracket = false;\n            let inSquareBrackets = false;\n            let hasOpenCurlyBracket = false;\n            while (j < len) {\n                let resetStateMachine = false;\n                const chCode = line.charCodeAt(j);\n                if (state === 13 /* Accept */) {\n                    let chClass;\n                    switch (chCode) {\n                        case 40 /* OpenParen */:\n                            hasOpenParens = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 41 /* CloseParen */:\n                            chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 91 /* OpenSquareBracket */:\n                            inSquareBrackets = true;\n                            hasOpenSquareBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 93 /* CloseSquareBracket */:\n                            inSquareBrackets = false;\n                            chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        case 123 /* OpenCurlyBrace */:\n                            hasOpenCurlyBracket = true;\n                            chClass = 0 /* None */;\n                            break;\n                        case 125 /* CloseCurlyBrace */:\n                            chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        /* The following three rules make it that ' or \" or ` are allowed inside links if the link began with a different one */\n                        case 39 /* SingleQuote */:\n                            chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 34 /* DoubleQuote */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 96 /* BackTick */:\n                            chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;\n                            break;\n                        case 42 /* Asterisk */:\n                            // `*` terminates a link if the link began with `*`\n                            chClass = (linkBeginChCode === 42 /* Asterisk */) ? 1 /* ForceTermination */ : 0 /* None */;\n                            break;\n                        case 124 /* Pipe */:\n                            // `|` terminates a link if the link began with `|`\n                            chClass = (linkBeginChCode === 124 /* Pipe */) ? 1 /* ForceTermination */ : 0 /* None */;\n                            break;\n                        case 32 /* Space */:\n                            // ` ` allow space in between [ and ]\n                            chClass = (inSquareBrackets ? 0 /* None */ : 1 /* ForceTermination */);\n                            break;\n                        default:\n                            chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n                        resetStateMachine = true;\n                    }\n                }\n                else if (state === 12 /* End */) {\n                    let chClass;\n                    if (chCode === 91 /* OpenSquareBracket */) {\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n                        hasOpenSquareBracket = true;\n                        chClass = 0 /* None */;\n                    }\n                    else {\n                        chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* ForceTermination */) {\n                        resetStateMachine = true;\n                    }\n                    else {\n                        state = 13 /* Accept */;\n                    }\n                }\n                else {\n                    state = stateMachine.nextState(state, chCode);\n                    if (state === 0 /* Invalid */) {\n                        resetStateMachine = true;\n                    }\n                }\n                if (resetStateMachine) {\n                    state = 1 /* Start */;\n                    hasOpenParens = false;\n                    hasOpenSquareBracket = false;\n                    hasOpenCurlyBracket = false;\n                    // Record where the link started\n                    linkBeginIndex = j + 1;\n                    linkBeginChCode = chCode;\n                }\n                j++;\n            }\n            if (state === 13 /* Accept */) {\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n            }\n        }\n        return result;\n    }\n}\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nexport function computeLinks(model) {\n    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n        // Unknown caller!\n        return [];\n    }\n    return LinkComputer.computeLinks(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class BasicInplaceReplace {\n    constructor() {\n        this._defaultValueSet = [\n            ['true', 'false'],\n            ['True', 'False'],\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n            ['public', 'protected', 'private'],\n        ];\n    }\n    navigateValueSet(range1, text1, range2, text2, up) {\n        if (range1 && text1) {\n            let result = this.doNavigateValueSet(text1, up);\n            if (result) {\n                return {\n                    range: range1,\n                    value: result\n                };\n            }\n        }\n        if (range2 && text2) {\n            let result = this.doNavigateValueSet(text2, up);\n            if (result) {\n                return {\n                    range: range2,\n                    value: result\n                };\n            }\n        }\n        return null;\n    }\n    doNavigateValueSet(text, up) {\n        let numberResult = this.numberReplace(text, up);\n        if (numberResult !== null) {\n            return numberResult;\n        }\n        return this.textReplace(text, up);\n    }\n    numberReplace(value, up) {\n        let precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n        let n1 = Number(value);\n        let n2 = parseFloat(value);\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n            if (n1 === 0 && !up) {\n                return null; // don't do negative\n                //\t\t\t} else if(n1 === 9 && up) {\n                //\t\t\t\treturn null; // don't insert 10 into a number\n            }\n            else {\n                n1 = Math.floor(n1 * precision);\n                n1 += up ? precision : -precision;\n                return String(n1 / precision);\n            }\n        }\n        return null;\n    }\n    textReplace(value, up) {\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\n    }\n    valueSetsReplace(valueSets, value, up) {\n        let result = null;\n        for (let i = 0, len = valueSets.length; result === null && i < len; i++) {\n            result = this.valueSetReplace(valueSets[i], value, up);\n        }\n        return result;\n    }\n    valueSetReplace(valueSet, value, up) {\n        let idx = valueSet.indexOf(value);\n        if (idx >= 0) {\n            idx += up ? +1 : -1;\n            if (idx < 0) {\n                idx = valueSet.length - 1;\n            }\n            else {\n                idx %= valueSet.length;\n            }\n            return valueSet[idx];\n        }\n        return null;\n    }\n}\nBasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter, Event } from './event.js';\nconst shortcutEvent = Object.freeze(function (callback, context) {\n    const handle = setTimeout(callback.bind(context), 0);\n    return { dispose() { clearTimeout(handle); } };\n});\nexport var CancellationToken;\n(function (CancellationToken) {\n    function isCancellationToken(thing) {\n        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {\n            return true;\n        }\n        if (thing instanceof MutableToken) {\n            return true;\n        }\n        if (!thing || typeof thing !== 'object') {\n            return false;\n        }\n        return typeof thing.isCancellationRequested === 'boolean'\n            && typeof thing.onCancellationRequested === 'function';\n    }\n    CancellationToken.isCancellationToken = isCancellationToken;\n    CancellationToken.None = Object.freeze({\n        isCancellationRequested: false,\n        onCancellationRequested: Event.None\n    });\n    CancellationToken.Cancelled = Object.freeze({\n        isCancellationRequested: true,\n        onCancellationRequested: shortcutEvent\n    });\n})(CancellationToken || (CancellationToken = {}));\nclass MutableToken {\n    constructor() {\n        this._isCancelled = false;\n        this._emitter = null;\n    }\n    cancel() {\n        if (!this._isCancelled) {\n            this._isCancelled = true;\n            if (this._emitter) {\n                this._emitter.fire(undefined);\n                this.dispose();\n            }\n        }\n    }\n    get isCancellationRequested() {\n        return this._isCancelled;\n    }\n    get onCancellationRequested() {\n        if (this._isCancelled) {\n            return shortcutEvent;\n        }\n        if (!this._emitter) {\n            this._emitter = new Emitter();\n        }\n        return this._emitter.event;\n    }\n    dispose() {\n        if (this._emitter) {\n            this._emitter.dispose();\n            this._emitter = null;\n        }\n    }\n}\nexport class CancellationTokenSource {\n    constructor(parent) {\n        this._token = undefined;\n        this._parentListener = undefined;\n        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);\n    }\n    get token() {\n        if (!this._token) {\n            // be lazy and create the token only when\n            // actually needed\n            this._token = new MutableToken();\n        }\n        return this._token;\n    }\n    cancel() {\n        if (!this._token) {\n            // save an object by returning the default\n            // cancelled token when cancellation happens\n            // before someone asks for the token\n            this._token = CancellationToken.Cancelled;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually cancel\n            this._token.cancel();\n        }\n    }\n    dispose(cancel = false) {\n        if (cancel) {\n            this.cancel();\n        }\n        if (this._parentListener) {\n            this._parentListener.dispose();\n        }\n        if (!this._token) {\n            // ensure to initialize with an empty token if we had none\n            this._token = CancellationToken.None;\n        }\n        else if (this._token instanceof MutableToken) {\n            // actually dispose\n            this._token.dispose();\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nclass KeyCodeStrMap {\n    constructor() {\n        this._keyCodeToStr = [];\n        this._strToKeyCode = Object.create(null);\n    }\n    define(keyCode, str) {\n        this._keyCodeToStr[keyCode] = str;\n        this._strToKeyCode[str.toLowerCase()] = keyCode;\n    }\n    keyCodeToStr(keyCode) {\n        return this._keyCodeToStr[keyCode];\n    }\n    strToKeyCode(str) {\n        return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;\n    }\n}\nconst uiMap = new KeyCodeStrMap();\nconst userSettingsUSMap = new KeyCodeStrMap();\nconst userSettingsGeneralMap = new KeyCodeStrMap();\nexport const EVENT_KEY_CODE_MAP = new Array(230);\nexport const NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE = {};\nconst scanCodeIntToStr = [];\nconst scanCodeStrToInt = Object.create(null);\nconst scanCodeLowerCaseStrToInt = Object.create(null);\n/**\n * -1 if a ScanCode => KeyCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_CODE_TO_KEY_CODE = [];\n/**\n * -1 if a KeyCode => ScanCode mapping depends on kb layout.\n */\nexport const IMMUTABLE_KEY_CODE_TO_CODE = [];\nfor (let i = 0; i <= 193 /* MAX_VALUE */; i++) {\n    IMMUTABLE_CODE_TO_KEY_CODE[i] = -1 /* DependsOnKbLayout */;\n}\nfor (let i = 0; i <= 126 /* MAX_VALUE */; i++) {\n    IMMUTABLE_KEY_CODE_TO_CODE[i] = -1 /* DependsOnKbLayout */;\n}\n(function () {\n    // See https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n    // See https://github.com/microsoft/node-native-keymap/blob/master/deps/chromium/keyboard_codes_win.h\n    const empty = '';\n    const mappings = [\n        // keyCodeOrd, immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel\n        [0, 1, 0 /* None */, 'None', 0 /* Unknown */, 'unknown', 0, 'VK_UNKNOWN', empty, empty],\n        [0, 1, 1 /* Hyper */, 'Hyper', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 2 /* Super */, 'Super', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 3 /* Fn */, 'Fn', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 4 /* FnLock */, 'FnLock', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 5 /* Suspend */, 'Suspend', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 6 /* Resume */, 'Resume', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 7 /* Turbo */, 'Turbo', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 8 /* Sleep */, 'Sleep', 0 /* Unknown */, empty, 0, 'VK_SLEEP', empty, empty],\n        [0, 1, 9 /* WakeUp */, 'WakeUp', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [31, 0, 10 /* KeyA */, 'KeyA', 31 /* KeyA */, 'A', 65, 'VK_A', empty, empty],\n        [32, 0, 11 /* KeyB */, 'KeyB', 32 /* KeyB */, 'B', 66, 'VK_B', empty, empty],\n        [33, 0, 12 /* KeyC */, 'KeyC', 33 /* KeyC */, 'C', 67, 'VK_C', empty, empty],\n        [34, 0, 13 /* KeyD */, 'KeyD', 34 /* KeyD */, 'D', 68, 'VK_D', empty, empty],\n        [35, 0, 14 /* KeyE */, 'KeyE', 35 /* KeyE */, 'E', 69, 'VK_E', empty, empty],\n        [36, 0, 15 /* KeyF */, 'KeyF', 36 /* KeyF */, 'F', 70, 'VK_F', empty, empty],\n        [37, 0, 16 /* KeyG */, 'KeyG', 37 /* KeyG */, 'G', 71, 'VK_G', empty, empty],\n        [38, 0, 17 /* KeyH */, 'KeyH', 38 /* KeyH */, 'H', 72, 'VK_H', empty, empty],\n        [39, 0, 18 /* KeyI */, 'KeyI', 39 /* KeyI */, 'I', 73, 'VK_I', empty, empty],\n        [40, 0, 19 /* KeyJ */, 'KeyJ', 40 /* KeyJ */, 'J', 74, 'VK_J', empty, empty],\n        [41, 0, 20 /* KeyK */, 'KeyK', 41 /* KeyK */, 'K', 75, 'VK_K', empty, empty],\n        [42, 0, 21 /* KeyL */, 'KeyL', 42 /* KeyL */, 'L', 76, 'VK_L', empty, empty],\n        [43, 0, 22 /* KeyM */, 'KeyM', 43 /* KeyM */, 'M', 77, 'VK_M', empty, empty],\n        [44, 0, 23 /* KeyN */, 'KeyN', 44 /* KeyN */, 'N', 78, 'VK_N', empty, empty],\n        [45, 0, 24 /* KeyO */, 'KeyO', 45 /* KeyO */, 'O', 79, 'VK_O', empty, empty],\n        [46, 0, 25 /* KeyP */, 'KeyP', 46 /* KeyP */, 'P', 80, 'VK_P', empty, empty],\n        [47, 0, 26 /* KeyQ */, 'KeyQ', 47 /* KeyQ */, 'Q', 81, 'VK_Q', empty, empty],\n        [48, 0, 27 /* KeyR */, 'KeyR', 48 /* KeyR */, 'R', 82, 'VK_R', empty, empty],\n        [49, 0, 28 /* KeyS */, 'KeyS', 49 /* KeyS */, 'S', 83, 'VK_S', empty, empty],\n        [50, 0, 29 /* KeyT */, 'KeyT', 50 /* KeyT */, 'T', 84, 'VK_T', empty, empty],\n        [51, 0, 30 /* KeyU */, 'KeyU', 51 /* KeyU */, 'U', 85, 'VK_U', empty, empty],\n        [52, 0, 31 /* KeyV */, 'KeyV', 52 /* KeyV */, 'V', 86, 'VK_V', empty, empty],\n        [53, 0, 32 /* KeyW */, 'KeyW', 53 /* KeyW */, 'W', 87, 'VK_W', empty, empty],\n        [54, 0, 33 /* KeyX */, 'KeyX', 54 /* KeyX */, 'X', 88, 'VK_X', empty, empty],\n        [55, 0, 34 /* KeyY */, 'KeyY', 55 /* KeyY */, 'Y', 89, 'VK_Y', empty, empty],\n        [56, 0, 35 /* KeyZ */, 'KeyZ', 56 /* KeyZ */, 'Z', 90, 'VK_Z', empty, empty],\n        [22, 0, 36 /* Digit1 */, 'Digit1', 22 /* Digit1 */, '1', 49, 'VK_1', empty, empty],\n        [23, 0, 37 /* Digit2 */, 'Digit2', 23 /* Digit2 */, '2', 50, 'VK_2', empty, empty],\n        [24, 0, 38 /* Digit3 */, 'Digit3', 24 /* Digit3 */, '3', 51, 'VK_3', empty, empty],\n        [25, 0, 39 /* Digit4 */, 'Digit4', 25 /* Digit4 */, '4', 52, 'VK_4', empty, empty],\n        [26, 0, 40 /* Digit5 */, 'Digit5', 26 /* Digit5 */, '5', 53, 'VK_5', empty, empty],\n        [27, 0, 41 /* Digit6 */, 'Digit6', 27 /* Digit6 */, '6', 54, 'VK_6', empty, empty],\n        [28, 0, 42 /* Digit7 */, 'Digit7', 28 /* Digit7 */, '7', 55, 'VK_7', empty, empty],\n        [29, 0, 43 /* Digit8 */, 'Digit8', 29 /* Digit8 */, '8', 56, 'VK_8', empty, empty],\n        [30, 0, 44 /* Digit9 */, 'Digit9', 30 /* Digit9 */, '9', 57, 'VK_9', empty, empty],\n        [21, 0, 45 /* Digit0 */, 'Digit0', 21 /* Digit0 */, '0', 48, 'VK_0', empty, empty],\n        [3, 1, 46 /* Enter */, 'Enter', 3 /* Enter */, 'Enter', 13, 'VK_RETURN', empty, empty],\n        [9, 1, 47 /* Escape */, 'Escape', 9 /* Escape */, 'Escape', 27, 'VK_ESCAPE', empty, empty],\n        [1, 1, 48 /* Backspace */, 'Backspace', 1 /* Backspace */, 'Backspace', 8, 'VK_BACK', empty, empty],\n        [2, 1, 49 /* Tab */, 'Tab', 2 /* Tab */, 'Tab', 9, 'VK_TAB', empty, empty],\n        [10, 1, 50 /* Space */, 'Space', 10 /* Space */, 'Space', 32, 'VK_SPACE', empty, empty],\n        [83, 0, 51 /* Minus */, 'Minus', 83 /* Minus */, '-', 189, 'VK_OEM_MINUS', '-', 'OEM_MINUS'],\n        [81, 0, 52 /* Equal */, 'Equal', 81 /* Equal */, '=', 187, 'VK_OEM_PLUS', '=', 'OEM_PLUS'],\n        [87, 0, 53 /* BracketLeft */, 'BracketLeft', 87 /* BracketLeft */, '[', 219, 'VK_OEM_4', '[', 'OEM_4'],\n        [89, 0, 54 /* BracketRight */, 'BracketRight', 89 /* BracketRight */, ']', 221, 'VK_OEM_6', ']', 'OEM_6'],\n        [88, 0, 55 /* Backslash */, 'Backslash', 88 /* Backslash */, '\\\\', 220, 'VK_OEM_5', '\\\\', 'OEM_5'],\n        [0, 0, 56 /* IntlHash */, 'IntlHash', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [80, 0, 57 /* Semicolon */, 'Semicolon', 80 /* Semicolon */, ';', 186, 'VK_OEM_1', ';', 'OEM_1'],\n        [90, 0, 58 /* Quote */, 'Quote', 90 /* Quote */, '\\'', 222, 'VK_OEM_7', '\\'', 'OEM_7'],\n        [86, 0, 59 /* Backquote */, 'Backquote', 86 /* Backquote */, '`', 192, 'VK_OEM_3', '`', 'OEM_3'],\n        [82, 0, 60 /* Comma */, 'Comma', 82 /* Comma */, ',', 188, 'VK_OEM_COMMA', ',', 'OEM_COMMA'],\n        [84, 0, 61 /* Period */, 'Period', 84 /* Period */, '.', 190, 'VK_OEM_PERIOD', '.', 'OEM_PERIOD'],\n        [85, 0, 62 /* Slash */, 'Slash', 85 /* Slash */, '/', 191, 'VK_OEM_2', '/', 'OEM_2'],\n        [8, 1, 63 /* CapsLock */, 'CapsLock', 8 /* CapsLock */, 'CapsLock', 20, 'VK_CAPITAL', empty, empty],\n        [59, 1, 64 /* F1 */, 'F1', 59 /* F1 */, 'F1', 112, 'VK_F1', empty, empty],\n        [60, 1, 65 /* F2 */, 'F2', 60 /* F2 */, 'F2', 113, 'VK_F2', empty, empty],\n        [61, 1, 66 /* F3 */, 'F3', 61 /* F3 */, 'F3', 114, 'VK_F3', empty, empty],\n        [62, 1, 67 /* F4 */, 'F4', 62 /* F4 */, 'F4', 115, 'VK_F4', empty, empty],\n        [63, 1, 68 /* F5 */, 'F5', 63 /* F5 */, 'F5', 116, 'VK_F5', empty, empty],\n        [64, 1, 69 /* F6 */, 'F6', 64 /* F6 */, 'F6', 117, 'VK_F6', empty, empty],\n        [65, 1, 70 /* F7 */, 'F7', 65 /* F7 */, 'F7', 118, 'VK_F7', empty, empty],\n        [66, 1, 71 /* F8 */, 'F8', 66 /* F8 */, 'F8', 119, 'VK_F8', empty, empty],\n        [67, 1, 72 /* F9 */, 'F9', 67 /* F9 */, 'F9', 120, 'VK_F9', empty, empty],\n        [68, 1, 73 /* F10 */, 'F10', 68 /* F10 */, 'F10', 121, 'VK_F10', empty, empty],\n        [69, 1, 74 /* F11 */, 'F11', 69 /* F11 */, 'F11', 122, 'VK_F11', empty, empty],\n        [70, 1, 75 /* F12 */, 'F12', 70 /* F12 */, 'F12', 123, 'VK_F12', empty, empty],\n        [0, 1, 76 /* PrintScreen */, 'PrintScreen', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [79, 1, 77 /* ScrollLock */, 'ScrollLock', 79 /* ScrollLock */, 'ScrollLock', 145, 'VK_SCROLL', empty, empty],\n        [7, 1, 78 /* Pause */, 'Pause', 7 /* PauseBreak */, 'PauseBreak', 19, 'VK_PAUSE', empty, empty],\n        [19, 1, 79 /* Insert */, 'Insert', 19 /* Insert */, 'Insert', 45, 'VK_INSERT', empty, empty],\n        [14, 1, 80 /* Home */, 'Home', 14 /* Home */, 'Home', 36, 'VK_HOME', empty, empty],\n        [11, 1, 81 /* PageUp */, 'PageUp', 11 /* PageUp */, 'PageUp', 33, 'VK_PRIOR', empty, empty],\n        [20, 1, 82 /* Delete */, 'Delete', 20 /* Delete */, 'Delete', 46, 'VK_DELETE', empty, empty],\n        [13, 1, 83 /* End */, 'End', 13 /* End */, 'End', 35, 'VK_END', empty, empty],\n        [12, 1, 84 /* PageDown */, 'PageDown', 12 /* PageDown */, 'PageDown', 34, 'VK_NEXT', empty, empty],\n        [17, 1, 85 /* ArrowRight */, 'ArrowRight', 17 /* RightArrow */, 'RightArrow', 39, 'VK_RIGHT', 'Right', empty],\n        [15, 1, 86 /* ArrowLeft */, 'ArrowLeft', 15 /* LeftArrow */, 'LeftArrow', 37, 'VK_LEFT', 'Left', empty],\n        [18, 1, 87 /* ArrowDown */, 'ArrowDown', 18 /* DownArrow */, 'DownArrow', 40, 'VK_DOWN', 'Down', empty],\n        [16, 1, 88 /* ArrowUp */, 'ArrowUp', 16 /* UpArrow */, 'UpArrow', 38, 'VK_UP', 'Up', empty],\n        [78, 1, 89 /* NumLock */, 'NumLock', 78 /* NumLock */, 'NumLock', 144, 'VK_NUMLOCK', empty, empty],\n        [108, 1, 90 /* NumpadDivide */, 'NumpadDivide', 108 /* NumpadDivide */, 'NumPad_Divide', 111, 'VK_DIVIDE', empty, empty],\n        [103, 1, 91 /* NumpadMultiply */, 'NumpadMultiply', 103 /* NumpadMultiply */, 'NumPad_Multiply', 106, 'VK_MULTIPLY', empty, empty],\n        [106, 1, 92 /* NumpadSubtract */, 'NumpadSubtract', 106 /* NumpadSubtract */, 'NumPad_Subtract', 109, 'VK_SUBTRACT', empty, empty],\n        [104, 1, 93 /* NumpadAdd */, 'NumpadAdd', 104 /* NumpadAdd */, 'NumPad_Add', 107, 'VK_ADD', empty, empty],\n        [3, 1, 94 /* NumpadEnter */, 'NumpadEnter', 3 /* Enter */, empty, 0, empty, empty, empty],\n        [94, 1, 95 /* Numpad1 */, 'Numpad1', 94 /* Numpad1 */, 'NumPad1', 97, 'VK_NUMPAD1', empty, empty],\n        [95, 1, 96 /* Numpad2 */, 'Numpad2', 95 /* Numpad2 */, 'NumPad2', 98, 'VK_NUMPAD2', empty, empty],\n        [96, 1, 97 /* Numpad3 */, 'Numpad3', 96 /* Numpad3 */, 'NumPad3', 99, 'VK_NUMPAD3', empty, empty],\n        [97, 1, 98 /* Numpad4 */, 'Numpad4', 97 /* Numpad4 */, 'NumPad4', 100, 'VK_NUMPAD4', empty, empty],\n        [98, 1, 99 /* Numpad5 */, 'Numpad5', 98 /* Numpad5 */, 'NumPad5', 101, 'VK_NUMPAD5', empty, empty],\n        [99, 1, 100 /* Numpad6 */, 'Numpad6', 99 /* Numpad6 */, 'NumPad6', 102, 'VK_NUMPAD6', empty, empty],\n        [100, 1, 101 /* Numpad7 */, 'Numpad7', 100 /* Numpad7 */, 'NumPad7', 103, 'VK_NUMPAD7', empty, empty],\n        [101, 1, 102 /* Numpad8 */, 'Numpad8', 101 /* Numpad8 */, 'NumPad8', 104, 'VK_NUMPAD8', empty, empty],\n        [102, 1, 103 /* Numpad9 */, 'Numpad9', 102 /* Numpad9 */, 'NumPad9', 105, 'VK_NUMPAD9', empty, empty],\n        [93, 1, 104 /* Numpad0 */, 'Numpad0', 93 /* Numpad0 */, 'NumPad0', 96, 'VK_NUMPAD0', empty, empty],\n        [107, 1, 105 /* NumpadDecimal */, 'NumpadDecimal', 107 /* NumpadDecimal */, 'NumPad_Decimal', 110, 'VK_DECIMAL', empty, empty],\n        [92, 0, 106 /* IntlBackslash */, 'IntlBackslash', 92 /* IntlBackslash */, 'OEM_102', 226, 'VK_OEM_102', empty, empty],\n        [58, 1, 107 /* ContextMenu */, 'ContextMenu', 58 /* ContextMenu */, 'ContextMenu', 93, empty, empty, empty],\n        [0, 1, 108 /* Power */, 'Power', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 109 /* NumpadEqual */, 'NumpadEqual', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [71, 1, 110 /* F13 */, 'F13', 71 /* F13 */, 'F13', 124, 'VK_F13', empty, empty],\n        [72, 1, 111 /* F14 */, 'F14', 72 /* F14 */, 'F14', 125, 'VK_F14', empty, empty],\n        [73, 1, 112 /* F15 */, 'F15', 73 /* F15 */, 'F15', 126, 'VK_F15', empty, empty],\n        [74, 1, 113 /* F16 */, 'F16', 74 /* F16 */, 'F16', 127, 'VK_F16', empty, empty],\n        [75, 1, 114 /* F17 */, 'F17', 75 /* F17 */, 'F17', 128, 'VK_F17', empty, empty],\n        [76, 1, 115 /* F18 */, 'F18', 76 /* F18 */, 'F18', 129, 'VK_F18', empty, empty],\n        [77, 1, 116 /* F19 */, 'F19', 77 /* F19 */, 'F19', 130, 'VK_F19', empty, empty],\n        [0, 1, 117 /* F20 */, 'F20', 0 /* Unknown */, empty, 0, 'VK_F20', empty, empty],\n        [0, 1, 118 /* F21 */, 'F21', 0 /* Unknown */, empty, 0, 'VK_F21', empty, empty],\n        [0, 1, 119 /* F22 */, 'F22', 0 /* Unknown */, empty, 0, 'VK_F22', empty, empty],\n        [0, 1, 120 /* F23 */, 'F23', 0 /* Unknown */, empty, 0, 'VK_F23', empty, empty],\n        [0, 1, 121 /* F24 */, 'F24', 0 /* Unknown */, empty, 0, 'VK_F24', empty, empty],\n        [0, 1, 122 /* Open */, 'Open', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 123 /* Help */, 'Help', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 124 /* Select */, 'Select', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 125 /* Again */, 'Again', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 126 /* Undo */, 'Undo', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 127 /* Cut */, 'Cut', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 128 /* Copy */, 'Copy', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 129 /* Paste */, 'Paste', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 130 /* Find */, 'Find', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 131 /* AudioVolumeMute */, 'AudioVolumeMute', 112 /* AudioVolumeMute */, 'AudioVolumeMute', 173, 'VK_VOLUME_MUTE', empty, empty],\n        [0, 1, 132 /* AudioVolumeUp */, 'AudioVolumeUp', 113 /* AudioVolumeUp */, 'AudioVolumeUp', 175, 'VK_VOLUME_UP', empty, empty],\n        [0, 1, 133 /* AudioVolumeDown */, 'AudioVolumeDown', 114 /* AudioVolumeDown */, 'AudioVolumeDown', 174, 'VK_VOLUME_DOWN', empty, empty],\n        [105, 1, 134 /* NumpadComma */, 'NumpadComma', 105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator', 108, 'VK_SEPARATOR', empty, empty],\n        [110, 0, 135 /* IntlRo */, 'IntlRo', 110 /* ABNT_C1 */, 'ABNT_C1', 193, 'VK_ABNT_C1', empty, empty],\n        [0, 1, 136 /* KanaMode */, 'KanaMode', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 0, 137 /* IntlYen */, 'IntlYen', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 138 /* Convert */, 'Convert', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 139 /* NonConvert */, 'NonConvert', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 140 /* Lang1 */, 'Lang1', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 141 /* Lang2 */, 'Lang2', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 142 /* Lang3 */, 'Lang3', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 143 /* Lang4 */, 'Lang4', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 144 /* Lang5 */, 'Lang5', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 145 /* Abort */, 'Abort', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 146 /* Props */, 'Props', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 147 /* NumpadParenLeft */, 'NumpadParenLeft', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 148 /* NumpadParenRight */, 'NumpadParenRight', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 149 /* NumpadBackspace */, 'NumpadBackspace', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 150 /* NumpadMemoryStore */, 'NumpadMemoryStore', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 151 /* NumpadMemoryRecall */, 'NumpadMemoryRecall', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 152 /* NumpadMemoryClear */, 'NumpadMemoryClear', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 153 /* NumpadMemoryAdd */, 'NumpadMemoryAdd', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 154 /* NumpadMemorySubtract */, 'NumpadMemorySubtract', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 155 /* NumpadClear */, 'NumpadClear', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 156 /* NumpadClearEntry */, 'NumpadClearEntry', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [5, 1, 0 /* None */, empty, 5 /* Ctrl */, 'Ctrl', 17, 'VK_CONTROL', empty, empty],\n        [4, 1, 0 /* None */, empty, 4 /* Shift */, 'Shift', 16, 'VK_SHIFT', empty, empty],\n        [6, 1, 0 /* None */, empty, 6 /* Alt */, 'Alt', 18, 'VK_MENU', empty, empty],\n        [57, 1, 0 /* None */, empty, 57 /* Meta */, 'Meta', 0, 'VK_COMMAND', empty, empty],\n        [5, 1, 157 /* ControlLeft */, 'ControlLeft', 5 /* Ctrl */, empty, 0, 'VK_LCONTROL', empty, empty],\n        [4, 1, 158 /* ShiftLeft */, 'ShiftLeft', 4 /* Shift */, empty, 0, 'VK_LSHIFT', empty, empty],\n        [6, 1, 159 /* AltLeft */, 'AltLeft', 6 /* Alt */, empty, 0, 'VK_LMENU', empty, empty],\n        [57, 1, 160 /* MetaLeft */, 'MetaLeft', 57 /* Meta */, empty, 0, 'VK_LWIN', empty, empty],\n        [5, 1, 161 /* ControlRight */, 'ControlRight', 5 /* Ctrl */, empty, 0, 'VK_RCONTROL', empty, empty],\n        [4, 1, 162 /* ShiftRight */, 'ShiftRight', 4 /* Shift */, empty, 0, 'VK_RSHIFT', empty, empty],\n        [6, 1, 163 /* AltRight */, 'AltRight', 6 /* Alt */, empty, 0, 'VK_RMENU', empty, empty],\n        [57, 1, 164 /* MetaRight */, 'MetaRight', 57 /* Meta */, empty, 0, 'VK_RWIN', empty, empty],\n        [0, 1, 165 /* BrightnessUp */, 'BrightnessUp', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 166 /* BrightnessDown */, 'BrightnessDown', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 167 /* MediaPlay */, 'MediaPlay', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 168 /* MediaRecord */, 'MediaRecord', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 169 /* MediaFastForward */, 'MediaFastForward', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 170 /* MediaRewind */, 'MediaRewind', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [114, 1, 171 /* MediaTrackNext */, 'MediaTrackNext', 119 /* MediaTrackNext */, 'MediaTrackNext', 176, 'VK_MEDIA_NEXT_TRACK', empty, empty],\n        [115, 1, 172 /* MediaTrackPrevious */, 'MediaTrackPrevious', 120 /* MediaTrackPrevious */, 'MediaTrackPrevious', 177, 'VK_MEDIA_PREV_TRACK', empty, empty],\n        [116, 1, 173 /* MediaStop */, 'MediaStop', 121 /* MediaStop */, 'MediaStop', 178, 'VK_MEDIA_STOP', empty, empty],\n        [0, 1, 174 /* Eject */, 'Eject', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [117, 1, 175 /* MediaPlayPause */, 'MediaPlayPause', 122 /* MediaPlayPause */, 'MediaPlayPause', 179, 'VK_MEDIA_PLAY_PAUSE', empty, empty],\n        [0, 1, 176 /* MediaSelect */, 'MediaSelect', 123 /* LaunchMediaPlayer */, 'LaunchMediaPlayer', 181, 'VK_MEDIA_LAUNCH_MEDIA_SELECT', empty, empty],\n        [0, 1, 177 /* LaunchMail */, 'LaunchMail', 124 /* LaunchMail */, 'LaunchMail', 180, 'VK_MEDIA_LAUNCH_MAIL', empty, empty],\n        [0, 1, 178 /* LaunchApp2 */, 'LaunchApp2', 125 /* LaunchApp2 */, 'LaunchApp2', 183, 'VK_MEDIA_LAUNCH_APP2', empty, empty],\n        [0, 1, 179 /* LaunchApp1 */, 'LaunchApp1', 0 /* Unknown */, empty, 0, 'VK_MEDIA_LAUNCH_APP1', empty, empty],\n        [0, 1, 180 /* SelectTask */, 'SelectTask', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 181 /* LaunchScreenSaver */, 'LaunchScreenSaver', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 182 /* BrowserSearch */, 'BrowserSearch', 115 /* BrowserSearch */, 'BrowserSearch', 170, 'VK_BROWSER_SEARCH', empty, empty],\n        [0, 1, 183 /* BrowserHome */, 'BrowserHome', 116 /* BrowserHome */, 'BrowserHome', 172, 'VK_BROWSER_HOME', empty, empty],\n        [112, 1, 184 /* BrowserBack */, 'BrowserBack', 117 /* BrowserBack */, 'BrowserBack', 166, 'VK_BROWSER_BACK', empty, empty],\n        [113, 1, 185 /* BrowserForward */, 'BrowserForward', 118 /* BrowserForward */, 'BrowserForward', 167, 'VK_BROWSER_FORWARD', empty, empty],\n        [0, 1, 186 /* BrowserStop */, 'BrowserStop', 0 /* Unknown */, empty, 0, 'VK_BROWSER_STOP', empty, empty],\n        [0, 1, 187 /* BrowserRefresh */, 'BrowserRefresh', 0 /* Unknown */, empty, 0, 'VK_BROWSER_REFRESH', empty, empty],\n        [0, 1, 188 /* BrowserFavorites */, 'BrowserFavorites', 0 /* Unknown */, empty, 0, 'VK_BROWSER_FAVORITES', empty, empty],\n        [0, 1, 189 /* ZoomToggle */, 'ZoomToggle', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 190 /* MailReply */, 'MailReply', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 191 /* MailForward */, 'MailForward', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        [0, 1, 192 /* MailSend */, 'MailSend', 0 /* Unknown */, empty, 0, empty, empty, empty],\n        // See https://lists.w3.org/Archives/Public/www-dom/2010JulSep/att-0182/keyCode-spec.html\n        // If an Input Method Editor is processing key input and the event is keydown, return 229.\n        [109, 1, 0 /* None */, empty, 109 /* KEY_IN_COMPOSITION */, 'KeyInComposition', 229, empty, empty, empty],\n        [111, 1, 0 /* None */, empty, 111 /* ABNT_C2 */, 'ABNT_C2', 194, 'VK_ABNT_C2', empty, empty],\n        [91, 1, 0 /* None */, empty, 91 /* OEM_8 */, 'OEM_8', 223, 'VK_OEM_8', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CLEAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANGUL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_JUNJA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_FINAL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HANJA', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_KANJI', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CONVERT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONCONVERT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ACCEPT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_MODECHANGE', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SELECT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PRINT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXECUTE', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_SNAPSHOT', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_HELP', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_APPS', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PROCESSKEY', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PACKET', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_SBCSCHAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_DBE_DBCSCHAR', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ATTN', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_CRSEL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EXSEL', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_EREOF', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PLAY', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_ZOOM', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_NONAME', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_PA1', empty, empty],\n        [0, 1, 0 /* None */, empty, 0 /* Unknown */, empty, 0, 'VK_OEM_CLEAR', empty, empty],\n    ];\n    let seenKeyCode = [];\n    let seenScanCode = [];\n    for (const mapping of mappings) {\n        const [_keyCodeOrd, immutable, scanCode, scanCodeStr, keyCode, keyCodeStr, eventKeyCode, vkey, usUserSettingsLabel, generalUserSettingsLabel] = mapping;\n        if (!seenScanCode[scanCode]) {\n            seenScanCode[scanCode] = true;\n            scanCodeIntToStr[scanCode] = scanCodeStr;\n            scanCodeStrToInt[scanCodeStr] = scanCode;\n            scanCodeLowerCaseStrToInt[scanCodeStr.toLowerCase()] = scanCode;\n            if (immutable) {\n                IMMUTABLE_CODE_TO_KEY_CODE[scanCode] = keyCode;\n                if ((keyCode !== 0 /* Unknown */)\n                    && (keyCode !== 3 /* Enter */)\n                    && (keyCode !== 5 /* Ctrl */)\n                    && (keyCode !== 4 /* Shift */)\n                    && (keyCode !== 6 /* Alt */)\n                    && (keyCode !== 57 /* Meta */)) {\n                    IMMUTABLE_KEY_CODE_TO_CODE[keyCode] = scanCode;\n                }\n            }\n        }\n        if (!seenKeyCode[keyCode]) {\n            seenKeyCode[keyCode] = true;\n            if (!keyCodeStr) {\n                throw new Error(`String representation missing for key code ${keyCode} around scan code ${scanCodeStr}`);\n            }\n            uiMap.define(keyCode, keyCodeStr);\n            userSettingsUSMap.define(keyCode, usUserSettingsLabel || keyCodeStr);\n            userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel || usUserSettingsLabel || keyCodeStr);\n        }\n        if (eventKeyCode) {\n            EVENT_KEY_CODE_MAP[eventKeyCode] = keyCode;\n        }\n        if (vkey) {\n            NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[vkey] = keyCode;\n        }\n    }\n    // Manually added due to the exclusion above (due to duplication with NumpadEnter)\n    IMMUTABLE_KEY_CODE_TO_CODE[3 /* Enter */] = 46 /* Enter */;\n})();\nexport var KeyCodeUtils;\n(function (KeyCodeUtils) {\n    function toString(keyCode) {\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toString = toString;\n    function fromString(key) {\n        return uiMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromString = fromString;\n    function toUserSettingsUS(keyCode) {\n        return userSettingsUSMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;\n    function toUserSettingsGeneral(keyCode) {\n        return userSettingsGeneralMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;\n    function fromUserSettings(key) {\n        return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);\n    }\n    KeyCodeUtils.fromUserSettings = fromUserSettings;\n    function toElectronAccelerator(keyCode) {\n        if (keyCode >= 93 /* Numpad0 */ && keyCode <= 108 /* NumpadDivide */) {\n            // [Electron Accelerators] Electron is able to parse numpad keys, but unfortunately it\n            // renders them just as regular keys in menus. For example, num0 is rendered as \"0\",\n            // numdiv is rendered as \"/\", numsub is rendered as \"-\".\n            //\n            // This can lead to incredible confusion, as it makes numpad based keybindings indistinguishable\n            // from keybindings based on regular keys.\n            //\n            // We therefore need to fall back to custom rendering for numpad keys.\n            return null;\n        }\n        switch (keyCode) {\n            case 16 /* UpArrow */:\n                return 'Up';\n            case 18 /* DownArrow */:\n                return 'Down';\n            case 15 /* LeftArrow */:\n                return 'Left';\n            case 17 /* RightArrow */:\n                return 'Right';\n        }\n        return uiMap.keyCodeToStr(keyCode);\n    }\n    KeyCodeUtils.toElectronAccelerator = toElectronAccelerator;\n})(KeyCodeUtils || (KeyCodeUtils = {}));\nexport function KeyChord(firstPart, secondPart) {\n    const chordPart = ((secondPart & 0x0000FFFF) << 16) >>> 0;\n    return (firstPart | chordPart) >>> 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.\nexport var AccessibilitySupport;\n(function (AccessibilitySupport) {\n    /**\n     * This should be the browser case where it is not known if a screen reader is attached or no.\n     */\n    AccessibilitySupport[AccessibilitySupport[\"Unknown\"] = 0] = \"Unknown\";\n    AccessibilitySupport[AccessibilitySupport[\"Disabled\"] = 1] = \"Disabled\";\n    AccessibilitySupport[AccessibilitySupport[\"Enabled\"] = 2] = \"Enabled\";\n})(AccessibilitySupport || (AccessibilitySupport = {}));\nexport var CompletionItemInsertTextRule;\n(function (CompletionItemInsertTextRule) {\n    /**\n     * Adjust whitespace/indentation of multiline insert texts to\n     * match the current line indentation.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"KeepWhitespace\"] = 1] = \"KeepWhitespace\";\n    /**\n     * `insertText` is a snippet.\n     */\n    CompletionItemInsertTextRule[CompletionItemInsertTextRule[\"InsertAsSnippet\"] = 4] = \"InsertAsSnippet\";\n})(CompletionItemInsertTextRule || (CompletionItemInsertTextRule = {}));\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind[CompletionItemKind[\"Method\"] = 0] = \"Method\";\n    CompletionItemKind[CompletionItemKind[\"Function\"] = 1] = \"Function\";\n    CompletionItemKind[CompletionItemKind[\"Constructor\"] = 2] = \"Constructor\";\n    CompletionItemKind[CompletionItemKind[\"Field\"] = 3] = \"Field\";\n    CompletionItemKind[CompletionItemKind[\"Variable\"] = 4] = \"Variable\";\n    CompletionItemKind[CompletionItemKind[\"Class\"] = 5] = \"Class\";\n    CompletionItemKind[CompletionItemKind[\"Struct\"] = 6] = \"Struct\";\n    CompletionItemKind[CompletionItemKind[\"Interface\"] = 7] = \"Interface\";\n    CompletionItemKind[CompletionItemKind[\"Module\"] = 8] = \"Module\";\n    CompletionItemKind[CompletionItemKind[\"Property\"] = 9] = \"Property\";\n    CompletionItemKind[CompletionItemKind[\"Event\"] = 10] = \"Event\";\n    CompletionItemKind[CompletionItemKind[\"Operator\"] = 11] = \"Operator\";\n    CompletionItemKind[CompletionItemKind[\"Unit\"] = 12] = \"Unit\";\n    CompletionItemKind[CompletionItemKind[\"Value\"] = 13] = \"Value\";\n    CompletionItemKind[CompletionItemKind[\"Constant\"] = 14] = \"Constant\";\n    CompletionItemKind[CompletionItemKind[\"Enum\"] = 15] = \"Enum\";\n    CompletionItemKind[CompletionItemKind[\"EnumMember\"] = 16] = \"EnumMember\";\n    CompletionItemKind[CompletionItemKind[\"Keyword\"] = 17] = \"Keyword\";\n    CompletionItemKind[CompletionItemKind[\"Text\"] = 18] = \"Text\";\n    CompletionItemKind[CompletionItemKind[\"Color\"] = 19] = \"Color\";\n    CompletionItemKind[CompletionItemKind[\"File\"] = 20] = \"File\";\n    CompletionItemKind[CompletionItemKind[\"Reference\"] = 21] = \"Reference\";\n    CompletionItemKind[CompletionItemKind[\"Customcolor\"] = 22] = \"Customcolor\";\n    CompletionItemKind[CompletionItemKind[\"Folder\"] = 23] = \"Folder\";\n    CompletionItemKind[CompletionItemKind[\"TypeParameter\"] = 24] = \"TypeParameter\";\n    CompletionItemKind[CompletionItemKind[\"User\"] = 25] = \"User\";\n    CompletionItemKind[CompletionItemKind[\"Issue\"] = 26] = \"Issue\";\n    CompletionItemKind[CompletionItemKind[\"Snippet\"] = 27] = \"Snippet\";\n})(CompletionItemKind || (CompletionItemKind = {}));\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n    CompletionItemTag[CompletionItemTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * How a suggest provider was triggered.\n */\nexport var CompletionTriggerKind;\n(function (CompletionTriggerKind) {\n    CompletionTriggerKind[CompletionTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerCharacter\"] = 1] = \"TriggerCharacter\";\n    CompletionTriggerKind[CompletionTriggerKind[\"TriggerForIncompleteCompletions\"] = 2] = \"TriggerForIncompleteCompletions\";\n})(CompletionTriggerKind || (CompletionTriggerKind = {}));\n/**\n * A positioning preference for rendering content widgets.\n */\nexport var ContentWidgetPositionPreference;\n(function (ContentWidgetPositionPreference) {\n    /**\n     * Place the content widget exactly at a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"EXACT\"] = 0] = \"EXACT\";\n    /**\n     * Place the content widget above a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"ABOVE\"] = 1] = \"ABOVE\";\n    /**\n     * Place the content widget below a position\n     */\n    ContentWidgetPositionPreference[ContentWidgetPositionPreference[\"BELOW\"] = 2] = \"BELOW\";\n})(ContentWidgetPositionPreference || (ContentWidgetPositionPreference = {}));\n/**\n * Describes the reason the cursor has changed its position.\n */\nexport var CursorChangeReason;\n(function (CursorChangeReason) {\n    /**\n     * Unknown or not set.\n     */\n    CursorChangeReason[CursorChangeReason[\"NotSet\"] = 0] = \"NotSet\";\n    /**\n     * A `model.setValue()` was called.\n     */\n    CursorChangeReason[CursorChangeReason[\"ContentFlush\"] = 1] = \"ContentFlush\";\n    /**\n     * The `model` has been changed outside of this cursor and the cursor recovers its position from associated markers.\n     */\n    CursorChangeReason[CursorChangeReason[\"RecoverFromMarkers\"] = 2] = \"RecoverFromMarkers\";\n    /**\n     * There was an explicit user gesture.\n     */\n    CursorChangeReason[CursorChangeReason[\"Explicit\"] = 3] = \"Explicit\";\n    /**\n     * There was a Paste.\n     */\n    CursorChangeReason[CursorChangeReason[\"Paste\"] = 4] = \"Paste\";\n    /**\n     * There was an Undo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Undo\"] = 5] = \"Undo\";\n    /**\n     * There was a Redo.\n     */\n    CursorChangeReason[CursorChangeReason[\"Redo\"] = 6] = \"Redo\";\n})(CursorChangeReason || (CursorChangeReason = {}));\n/**\n * The default end of line to use when instantiating models.\n */\nexport var DefaultEndOfLine;\n(function (DefaultEndOfLine) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    DefaultEndOfLine[DefaultEndOfLine[\"CRLF\"] = 2] = \"CRLF\";\n})(DefaultEndOfLine || (DefaultEndOfLine = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * Configuration options for auto indentation in the editor\n */\nexport var EditorAutoIndentStrategy;\n(function (EditorAutoIndentStrategy) {\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"None\"] = 0] = \"None\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Keep\"] = 1] = \"Keep\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Brackets\"] = 2] = \"Brackets\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Advanced\"] = 3] = \"Advanced\";\n    EditorAutoIndentStrategy[EditorAutoIndentStrategy[\"Full\"] = 4] = \"Full\";\n})(EditorAutoIndentStrategy || (EditorAutoIndentStrategy = {}));\nexport var EditorOption;\n(function (EditorOption) {\n    EditorOption[EditorOption[\"acceptSuggestionOnCommitCharacter\"] = 0] = \"acceptSuggestionOnCommitCharacter\";\n    EditorOption[EditorOption[\"acceptSuggestionOnEnter\"] = 1] = \"acceptSuggestionOnEnter\";\n    EditorOption[EditorOption[\"accessibilitySupport\"] = 2] = \"accessibilitySupport\";\n    EditorOption[EditorOption[\"accessibilityPageSize\"] = 3] = \"accessibilityPageSize\";\n    EditorOption[EditorOption[\"ariaLabel\"] = 4] = \"ariaLabel\";\n    EditorOption[EditorOption[\"autoClosingBrackets\"] = 5] = \"autoClosingBrackets\";\n    EditorOption[EditorOption[\"autoClosingDelete\"] = 6] = \"autoClosingDelete\";\n    EditorOption[EditorOption[\"autoClosingOvertype\"] = 7] = \"autoClosingOvertype\";\n    EditorOption[EditorOption[\"autoClosingQuotes\"] = 8] = \"autoClosingQuotes\";\n    EditorOption[EditorOption[\"autoIndent\"] = 9] = \"autoIndent\";\n    EditorOption[EditorOption[\"automaticLayout\"] = 10] = \"automaticLayout\";\n    EditorOption[EditorOption[\"autoSurround\"] = 11] = \"autoSurround\";\n    EditorOption[EditorOption[\"bracketPairColorization\"] = 12] = \"bracketPairColorization\";\n    EditorOption[EditorOption[\"guides\"] = 13] = \"guides\";\n    EditorOption[EditorOption[\"codeLens\"] = 14] = \"codeLens\";\n    EditorOption[EditorOption[\"codeLensFontFamily\"] = 15] = \"codeLensFontFamily\";\n    EditorOption[EditorOption[\"codeLensFontSize\"] = 16] = \"codeLensFontSize\";\n    EditorOption[EditorOption[\"colorDecorators\"] = 17] = \"colorDecorators\";\n    EditorOption[EditorOption[\"columnSelection\"] = 18] = \"columnSelection\";\n    EditorOption[EditorOption[\"comments\"] = 19] = \"comments\";\n    EditorOption[EditorOption[\"contextmenu\"] = 20] = \"contextmenu\";\n    EditorOption[EditorOption[\"copyWithSyntaxHighlighting\"] = 21] = \"copyWithSyntaxHighlighting\";\n    EditorOption[EditorOption[\"cursorBlinking\"] = 22] = \"cursorBlinking\";\n    EditorOption[EditorOption[\"cursorSmoothCaretAnimation\"] = 23] = \"cursorSmoothCaretAnimation\";\n    EditorOption[EditorOption[\"cursorStyle\"] = 24] = \"cursorStyle\";\n    EditorOption[EditorOption[\"cursorSurroundingLines\"] = 25] = \"cursorSurroundingLines\";\n    EditorOption[EditorOption[\"cursorSurroundingLinesStyle\"] = 26] = \"cursorSurroundingLinesStyle\";\n    EditorOption[EditorOption[\"cursorWidth\"] = 27] = \"cursorWidth\";\n    EditorOption[EditorOption[\"disableLayerHinting\"] = 28] = \"disableLayerHinting\";\n    EditorOption[EditorOption[\"disableMonospaceOptimizations\"] = 29] = \"disableMonospaceOptimizations\";\n    EditorOption[EditorOption[\"domReadOnly\"] = 30] = \"domReadOnly\";\n    EditorOption[EditorOption[\"dragAndDrop\"] = 31] = \"dragAndDrop\";\n    EditorOption[EditorOption[\"emptySelectionClipboard\"] = 32] = \"emptySelectionClipboard\";\n    EditorOption[EditorOption[\"extraEditorClassName\"] = 33] = \"extraEditorClassName\";\n    EditorOption[EditorOption[\"fastScrollSensitivity\"] = 34] = \"fastScrollSensitivity\";\n    EditorOption[EditorOption[\"find\"] = 35] = \"find\";\n    EditorOption[EditorOption[\"fixedOverflowWidgets\"] = 36] = \"fixedOverflowWidgets\";\n    EditorOption[EditorOption[\"folding\"] = 37] = \"folding\";\n    EditorOption[EditorOption[\"foldingStrategy\"] = 38] = \"foldingStrategy\";\n    EditorOption[EditorOption[\"foldingHighlight\"] = 39] = \"foldingHighlight\";\n    EditorOption[EditorOption[\"foldingImportsByDefault\"] = 40] = \"foldingImportsByDefault\";\n    EditorOption[EditorOption[\"unfoldOnClickAfterEndOfLine\"] = 41] = \"unfoldOnClickAfterEndOfLine\";\n    EditorOption[EditorOption[\"fontFamily\"] = 42] = \"fontFamily\";\n    EditorOption[EditorOption[\"fontInfo\"] = 43] = \"fontInfo\";\n    EditorOption[EditorOption[\"fontLigatures\"] = 44] = \"fontLigatures\";\n    EditorOption[EditorOption[\"fontSize\"] = 45] = \"fontSize\";\n    EditorOption[EditorOption[\"fontWeight\"] = 46] = \"fontWeight\";\n    EditorOption[EditorOption[\"formatOnPaste\"] = 47] = \"formatOnPaste\";\n    EditorOption[EditorOption[\"formatOnType\"] = 48] = \"formatOnType\";\n    EditorOption[EditorOption[\"glyphMargin\"] = 49] = \"glyphMargin\";\n    EditorOption[EditorOption[\"gotoLocation\"] = 50] = \"gotoLocation\";\n    EditorOption[EditorOption[\"hideCursorInOverviewRuler\"] = 51] = \"hideCursorInOverviewRuler\";\n    EditorOption[EditorOption[\"hover\"] = 52] = \"hover\";\n    EditorOption[EditorOption[\"inDiffEditor\"] = 53] = \"inDiffEditor\";\n    EditorOption[EditorOption[\"inlineSuggest\"] = 54] = \"inlineSuggest\";\n    EditorOption[EditorOption[\"letterSpacing\"] = 55] = \"letterSpacing\";\n    EditorOption[EditorOption[\"lightbulb\"] = 56] = \"lightbulb\";\n    EditorOption[EditorOption[\"lineDecorationsWidth\"] = 57] = \"lineDecorationsWidth\";\n    EditorOption[EditorOption[\"lineHeight\"] = 58] = \"lineHeight\";\n    EditorOption[EditorOption[\"lineNumbers\"] = 59] = \"lineNumbers\";\n    EditorOption[EditorOption[\"lineNumbersMinChars\"] = 60] = \"lineNumbersMinChars\";\n    EditorOption[EditorOption[\"linkedEditing\"] = 61] = \"linkedEditing\";\n    EditorOption[EditorOption[\"links\"] = 62] = \"links\";\n    EditorOption[EditorOption[\"matchBrackets\"] = 63] = \"matchBrackets\";\n    EditorOption[EditorOption[\"minimap\"] = 64] = \"minimap\";\n    EditorOption[EditorOption[\"mouseStyle\"] = 65] = \"mouseStyle\";\n    EditorOption[EditorOption[\"mouseWheelScrollSensitivity\"] = 66] = \"mouseWheelScrollSensitivity\";\n    EditorOption[EditorOption[\"mouseWheelZoom\"] = 67] = \"mouseWheelZoom\";\n    EditorOption[EditorOption[\"multiCursorMergeOverlapping\"] = 68] = \"multiCursorMergeOverlapping\";\n    EditorOption[EditorOption[\"multiCursorModifier\"] = 69] = \"multiCursorModifier\";\n    EditorOption[EditorOption[\"multiCursorPaste\"] = 70] = \"multiCursorPaste\";\n    EditorOption[EditorOption[\"occurrencesHighlight\"] = 71] = \"occurrencesHighlight\";\n    EditorOption[EditorOption[\"overviewRulerBorder\"] = 72] = \"overviewRulerBorder\";\n    EditorOption[EditorOption[\"overviewRulerLanes\"] = 73] = \"overviewRulerLanes\";\n    EditorOption[EditorOption[\"padding\"] = 74] = \"padding\";\n    EditorOption[EditorOption[\"parameterHints\"] = 75] = \"parameterHints\";\n    EditorOption[EditorOption[\"peekWidgetDefaultFocus\"] = 76] = \"peekWidgetDefaultFocus\";\n    EditorOption[EditorOption[\"definitionLinkOpensInPeek\"] = 77] = \"definitionLinkOpensInPeek\";\n    EditorOption[EditorOption[\"quickSuggestions\"] = 78] = \"quickSuggestions\";\n    EditorOption[EditorOption[\"quickSuggestionsDelay\"] = 79] = \"quickSuggestionsDelay\";\n    EditorOption[EditorOption[\"readOnly\"] = 80] = \"readOnly\";\n    EditorOption[EditorOption[\"renameOnType\"] = 81] = \"renameOnType\";\n    EditorOption[EditorOption[\"renderControlCharacters\"] = 82] = \"renderControlCharacters\";\n    EditorOption[EditorOption[\"renderFinalNewline\"] = 83] = \"renderFinalNewline\";\n    EditorOption[EditorOption[\"renderLineHighlight\"] = 84] = \"renderLineHighlight\";\n    EditorOption[EditorOption[\"renderLineHighlightOnlyWhenFocus\"] = 85] = \"renderLineHighlightOnlyWhenFocus\";\n    EditorOption[EditorOption[\"renderValidationDecorations\"] = 86] = \"renderValidationDecorations\";\n    EditorOption[EditorOption[\"renderWhitespace\"] = 87] = \"renderWhitespace\";\n    EditorOption[EditorOption[\"revealHorizontalRightPadding\"] = 88] = \"revealHorizontalRightPadding\";\n    EditorOption[EditorOption[\"roundedSelection\"] = 89] = \"roundedSelection\";\n    EditorOption[EditorOption[\"rulers\"] = 90] = \"rulers\";\n    EditorOption[EditorOption[\"scrollbar\"] = 91] = \"scrollbar\";\n    EditorOption[EditorOption[\"scrollBeyondLastColumn\"] = 92] = \"scrollBeyondLastColumn\";\n    EditorOption[EditorOption[\"scrollBeyondLastLine\"] = 93] = \"scrollBeyondLastLine\";\n    EditorOption[EditorOption[\"scrollPredominantAxis\"] = 94] = \"scrollPredominantAxis\";\n    EditorOption[EditorOption[\"selectionClipboard\"] = 95] = \"selectionClipboard\";\n    EditorOption[EditorOption[\"selectionHighlight\"] = 96] = \"selectionHighlight\";\n    EditorOption[EditorOption[\"selectOnLineNumbers\"] = 97] = \"selectOnLineNumbers\";\n    EditorOption[EditorOption[\"showFoldingControls\"] = 98] = \"showFoldingControls\";\n    EditorOption[EditorOption[\"showUnused\"] = 99] = \"showUnused\";\n    EditorOption[EditorOption[\"snippetSuggestions\"] = 100] = \"snippetSuggestions\";\n    EditorOption[EditorOption[\"smartSelect\"] = 101] = \"smartSelect\";\n    EditorOption[EditorOption[\"smoothScrolling\"] = 102] = \"smoothScrolling\";\n    EditorOption[EditorOption[\"stickyTabStops\"] = 103] = \"stickyTabStops\";\n    EditorOption[EditorOption[\"stopRenderingLineAfter\"] = 104] = \"stopRenderingLineAfter\";\n    EditorOption[EditorOption[\"suggest\"] = 105] = \"suggest\";\n    EditorOption[EditorOption[\"suggestFontSize\"] = 106] = \"suggestFontSize\";\n    EditorOption[EditorOption[\"suggestLineHeight\"] = 107] = \"suggestLineHeight\";\n    EditorOption[EditorOption[\"suggestOnTriggerCharacters\"] = 108] = \"suggestOnTriggerCharacters\";\n    EditorOption[EditorOption[\"suggestSelection\"] = 109] = \"suggestSelection\";\n    EditorOption[EditorOption[\"tabCompletion\"] = 110] = \"tabCompletion\";\n    EditorOption[EditorOption[\"tabIndex\"] = 111] = \"tabIndex\";\n    EditorOption[EditorOption[\"unicodeHighlighting\"] = 112] = \"unicodeHighlighting\";\n    EditorOption[EditorOption[\"unusualLineTerminators\"] = 113] = \"unusualLineTerminators\";\n    EditorOption[EditorOption[\"useShadowDOM\"] = 114] = \"useShadowDOM\";\n    EditorOption[EditorOption[\"useTabStops\"] = 115] = \"useTabStops\";\n    EditorOption[EditorOption[\"wordSeparators\"] = 116] = \"wordSeparators\";\n    EditorOption[EditorOption[\"wordWrap\"] = 117] = \"wordWrap\";\n    EditorOption[EditorOption[\"wordWrapBreakAfterCharacters\"] = 118] = \"wordWrapBreakAfterCharacters\";\n    EditorOption[EditorOption[\"wordWrapBreakBeforeCharacters\"] = 119] = \"wordWrapBreakBeforeCharacters\";\n    EditorOption[EditorOption[\"wordWrapColumn\"] = 120] = \"wordWrapColumn\";\n    EditorOption[EditorOption[\"wordWrapOverride1\"] = 121] = \"wordWrapOverride1\";\n    EditorOption[EditorOption[\"wordWrapOverride2\"] = 122] = \"wordWrapOverride2\";\n    EditorOption[EditorOption[\"wrappingIndent\"] = 123] = \"wrappingIndent\";\n    EditorOption[EditorOption[\"wrappingStrategy\"] = 124] = \"wrappingStrategy\";\n    EditorOption[EditorOption[\"showDeprecated\"] = 125] = \"showDeprecated\";\n    EditorOption[EditorOption[\"inlayHints\"] = 126] = \"inlayHints\";\n    EditorOption[EditorOption[\"editorClassName\"] = 127] = \"editorClassName\";\n    EditorOption[EditorOption[\"pixelRatio\"] = 128] = \"pixelRatio\";\n    EditorOption[EditorOption[\"tabFocusMode\"] = 129] = \"tabFocusMode\";\n    EditorOption[EditorOption[\"layoutInfo\"] = 130] = \"layoutInfo\";\n    EditorOption[EditorOption[\"wrappingInfo\"] = 131] = \"wrappingInfo\";\n})(EditorOption || (EditorOption = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLinePreference;\n(function (EndOfLinePreference) {\n    /**\n     * Use the end of line character identified in the text buffer.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"TextDefined\"] = 0] = \"TextDefined\";\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"LF\"] = 1] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLinePreference[EndOfLinePreference[\"CRLF\"] = 2] = \"CRLF\";\n})(EndOfLinePreference || (EndOfLinePreference = {}));\n/**\n * End of line character preference.\n */\nexport var EndOfLineSequence;\n(function (EndOfLineSequence) {\n    /**\n     * Use line feed (\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"LF\"] = 0] = \"LF\";\n    /**\n     * Use carriage return and line feed (\\r\\n) as the end of line character.\n     */\n    EndOfLineSequence[EndOfLineSequence[\"CRLF\"] = 1] = \"CRLF\";\n})(EndOfLineSequence || (EndOfLineSequence = {}));\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nexport var IndentAction;\n(function (IndentAction) {\n    /**\n     * Insert new line and copy the previous line's indentation.\n     */\n    IndentAction[IndentAction[\"None\"] = 0] = \"None\";\n    /**\n     * Insert new line and indent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\n    /**\n     * Insert two new lines:\n     *  - the first one indented which will hold the cursor\n     *  - the second one at the same indentation level\n     */\n    IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\n    /**\n     * Insert new line and outdent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\n})(IndentAction || (IndentAction = {}));\nexport var InlayHintKind;\n(function (InlayHintKind) {\n    InlayHintKind[InlayHintKind[\"Other\"] = 0] = \"Other\";\n    InlayHintKind[InlayHintKind[\"Type\"] = 1] = \"Type\";\n    InlayHintKind[InlayHintKind[\"Parameter\"] = 2] = \"Parameter\";\n})(InlayHintKind || (InlayHintKind = {}));\n/**\n * How an {@link InlineCompletionsProvider inline completion provider} was triggered.\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n    /**\n     * Completion was triggered automatically while editing.\n     * It is sufficient to return a single completion item in this case.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n    /**\n     * Completion was triggered explicitly by a user gesture.\n     * Return multiple completion items to enable cycling through them.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Explicit\"] = 1] = \"Explicit\";\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\n/**\n * Virtual Key Codes, the value does not hold any inherent meaning.\n * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx\n * But these are \"more general\", as they should work across browsers & OS`s.\n */\nexport var KeyCode;\n(function (KeyCode) {\n    KeyCode[KeyCode[\"DependsOnKbLayout\"] = -1] = \"DependsOnKbLayout\";\n    /**\n     * Placed first to cover the 0 value of the enum.\n     */\n    KeyCode[KeyCode[\"Unknown\"] = 0] = \"Unknown\";\n    KeyCode[KeyCode[\"Backspace\"] = 1] = \"Backspace\";\n    KeyCode[KeyCode[\"Tab\"] = 2] = \"Tab\";\n    KeyCode[KeyCode[\"Enter\"] = 3] = \"Enter\";\n    KeyCode[KeyCode[\"Shift\"] = 4] = \"Shift\";\n    KeyCode[KeyCode[\"Ctrl\"] = 5] = \"Ctrl\";\n    KeyCode[KeyCode[\"Alt\"] = 6] = \"Alt\";\n    KeyCode[KeyCode[\"PauseBreak\"] = 7] = \"PauseBreak\";\n    KeyCode[KeyCode[\"CapsLock\"] = 8] = \"CapsLock\";\n    KeyCode[KeyCode[\"Escape\"] = 9] = \"Escape\";\n    KeyCode[KeyCode[\"Space\"] = 10] = \"Space\";\n    KeyCode[KeyCode[\"PageUp\"] = 11] = \"PageUp\";\n    KeyCode[KeyCode[\"PageDown\"] = 12] = \"PageDown\";\n    KeyCode[KeyCode[\"End\"] = 13] = \"End\";\n    KeyCode[KeyCode[\"Home\"] = 14] = \"Home\";\n    KeyCode[KeyCode[\"LeftArrow\"] = 15] = \"LeftArrow\";\n    KeyCode[KeyCode[\"UpArrow\"] = 16] = \"UpArrow\";\n    KeyCode[KeyCode[\"RightArrow\"] = 17] = \"RightArrow\";\n    KeyCode[KeyCode[\"DownArrow\"] = 18] = \"DownArrow\";\n    KeyCode[KeyCode[\"Insert\"] = 19] = \"Insert\";\n    KeyCode[KeyCode[\"Delete\"] = 20] = \"Delete\";\n    KeyCode[KeyCode[\"Digit0\"] = 21] = \"Digit0\";\n    KeyCode[KeyCode[\"Digit1\"] = 22] = \"Digit1\";\n    KeyCode[KeyCode[\"Digit2\"] = 23] = \"Digit2\";\n    KeyCode[KeyCode[\"Digit3\"] = 24] = \"Digit3\";\n    KeyCode[KeyCode[\"Digit4\"] = 25] = \"Digit4\";\n    KeyCode[KeyCode[\"Digit5\"] = 26] = \"Digit5\";\n    KeyCode[KeyCode[\"Digit6\"] = 27] = \"Digit6\";\n    KeyCode[KeyCode[\"Digit7\"] = 28] = \"Digit7\";\n    KeyCode[KeyCode[\"Digit8\"] = 29] = \"Digit8\";\n    KeyCode[KeyCode[\"Digit9\"] = 30] = \"Digit9\";\n    KeyCode[KeyCode[\"KeyA\"] = 31] = \"KeyA\";\n    KeyCode[KeyCode[\"KeyB\"] = 32] = \"KeyB\";\n    KeyCode[KeyCode[\"KeyC\"] = 33] = \"KeyC\";\n    KeyCode[KeyCode[\"KeyD\"] = 34] = \"KeyD\";\n    KeyCode[KeyCode[\"KeyE\"] = 35] = \"KeyE\";\n    KeyCode[KeyCode[\"KeyF\"] = 36] = \"KeyF\";\n    KeyCode[KeyCode[\"KeyG\"] = 37] = \"KeyG\";\n    KeyCode[KeyCode[\"KeyH\"] = 38] = \"KeyH\";\n    KeyCode[KeyCode[\"KeyI\"] = 39] = \"KeyI\";\n    KeyCode[KeyCode[\"KeyJ\"] = 40] = \"KeyJ\";\n    KeyCode[KeyCode[\"KeyK\"] = 41] = \"KeyK\";\n    KeyCode[KeyCode[\"KeyL\"] = 42] = \"KeyL\";\n    KeyCode[KeyCode[\"KeyM\"] = 43] = \"KeyM\";\n    KeyCode[KeyCode[\"KeyN\"] = 44] = \"KeyN\";\n    KeyCode[KeyCode[\"KeyO\"] = 45] = \"KeyO\";\n    KeyCode[KeyCode[\"KeyP\"] = 46] = \"KeyP\";\n    KeyCode[KeyCode[\"KeyQ\"] = 47] = \"KeyQ\";\n    KeyCode[KeyCode[\"KeyR\"] = 48] = \"KeyR\";\n    KeyCode[KeyCode[\"KeyS\"] = 49] = \"KeyS\";\n    KeyCode[KeyCode[\"KeyT\"] = 50] = \"KeyT\";\n    KeyCode[KeyCode[\"KeyU\"] = 51] = \"KeyU\";\n    KeyCode[KeyCode[\"KeyV\"] = 52] = \"KeyV\";\n    KeyCode[KeyCode[\"KeyW\"] = 53] = \"KeyW\";\n    KeyCode[KeyCode[\"KeyX\"] = 54] = \"KeyX\";\n    KeyCode[KeyCode[\"KeyY\"] = 55] = \"KeyY\";\n    KeyCode[KeyCode[\"KeyZ\"] = 56] = \"KeyZ\";\n    KeyCode[KeyCode[\"Meta\"] = 57] = \"Meta\";\n    KeyCode[KeyCode[\"ContextMenu\"] = 58] = \"ContextMenu\";\n    KeyCode[KeyCode[\"F1\"] = 59] = \"F1\";\n    KeyCode[KeyCode[\"F2\"] = 60] = \"F2\";\n    KeyCode[KeyCode[\"F3\"] = 61] = \"F3\";\n    KeyCode[KeyCode[\"F4\"] = 62] = \"F4\";\n    KeyCode[KeyCode[\"F5\"] = 63] = \"F5\";\n    KeyCode[KeyCode[\"F6\"] = 64] = \"F6\";\n    KeyCode[KeyCode[\"F7\"] = 65] = \"F7\";\n    KeyCode[KeyCode[\"F8\"] = 66] = \"F8\";\n    KeyCode[KeyCode[\"F9\"] = 67] = \"F9\";\n    KeyCode[KeyCode[\"F10\"] = 68] = \"F10\";\n    KeyCode[KeyCode[\"F11\"] = 69] = \"F11\";\n    KeyCode[KeyCode[\"F12\"] = 70] = \"F12\";\n    KeyCode[KeyCode[\"F13\"] = 71] = \"F13\";\n    KeyCode[KeyCode[\"F14\"] = 72] = \"F14\";\n    KeyCode[KeyCode[\"F15\"] = 73] = \"F15\";\n    KeyCode[KeyCode[\"F16\"] = 74] = \"F16\";\n    KeyCode[KeyCode[\"F17\"] = 75] = \"F17\";\n    KeyCode[KeyCode[\"F18\"] = 76] = \"F18\";\n    KeyCode[KeyCode[\"F19\"] = 77] = \"F19\";\n    KeyCode[KeyCode[\"NumLock\"] = 78] = \"NumLock\";\n    KeyCode[KeyCode[\"ScrollLock\"] = 79] = \"ScrollLock\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ';:' key\n     */\n    KeyCode[KeyCode[\"Semicolon\"] = 80] = \"Semicolon\";\n    /**\n     * For any country/region, the '+' key\n     * For the US standard keyboard, the '=+' key\n     */\n    KeyCode[KeyCode[\"Equal\"] = 81] = \"Equal\";\n    /**\n     * For any country/region, the ',' key\n     * For the US standard keyboard, the ',<' key\n     */\n    KeyCode[KeyCode[\"Comma\"] = 82] = \"Comma\";\n    /**\n     * For any country/region, the '-' key\n     * For the US standard keyboard, the '-_' key\n     */\n    KeyCode[KeyCode[\"Minus\"] = 83] = \"Minus\";\n    /**\n     * For any country/region, the '.' key\n     * For the US standard keyboard, the '.>' key\n     */\n    KeyCode[KeyCode[\"Period\"] = 84] = \"Period\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '/?' key\n     */\n    KeyCode[KeyCode[\"Slash\"] = 85] = \"Slash\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '`~' key\n     */\n    KeyCode[KeyCode[\"Backquote\"] = 86] = \"Backquote\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '[{' key\n     */\n    KeyCode[KeyCode[\"BracketLeft\"] = 87] = \"BracketLeft\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the '\\|' key\n     */\n    KeyCode[KeyCode[\"Backslash\"] = 88] = \"Backslash\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ']}' key\n     */\n    KeyCode[KeyCode[\"BracketRight\"] = 89] = \"BracketRight\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     * For the US standard keyboard, the ''\"' key\n     */\n    KeyCode[KeyCode[\"Quote\"] = 90] = \"Quote\";\n    /**\n     * Used for miscellaneous characters; it can vary by keyboard.\n     */\n    KeyCode[KeyCode[\"OEM_8\"] = 91] = \"OEM_8\";\n    /**\n     * Either the angle bracket key or the backslash key on the RT 102-key keyboard.\n     */\n    KeyCode[KeyCode[\"IntlBackslash\"] = 92] = \"IntlBackslash\";\n    KeyCode[KeyCode[\"Numpad0\"] = 93] = \"Numpad0\";\n    KeyCode[KeyCode[\"Numpad1\"] = 94] = \"Numpad1\";\n    KeyCode[KeyCode[\"Numpad2\"] = 95] = \"Numpad2\";\n    KeyCode[KeyCode[\"Numpad3\"] = 96] = \"Numpad3\";\n    KeyCode[KeyCode[\"Numpad4\"] = 97] = \"Numpad4\";\n    KeyCode[KeyCode[\"Numpad5\"] = 98] = \"Numpad5\";\n    KeyCode[KeyCode[\"Numpad6\"] = 99] = \"Numpad6\";\n    KeyCode[KeyCode[\"Numpad7\"] = 100] = \"Numpad7\";\n    KeyCode[KeyCode[\"Numpad8\"] = 101] = \"Numpad8\";\n    KeyCode[KeyCode[\"Numpad9\"] = 102] = \"Numpad9\";\n    KeyCode[KeyCode[\"NumpadMultiply\"] = 103] = \"NumpadMultiply\";\n    KeyCode[KeyCode[\"NumpadAdd\"] = 104] = \"NumpadAdd\";\n    KeyCode[KeyCode[\"NUMPAD_SEPARATOR\"] = 105] = \"NUMPAD_SEPARATOR\";\n    KeyCode[KeyCode[\"NumpadSubtract\"] = 106] = \"NumpadSubtract\";\n    KeyCode[KeyCode[\"NumpadDecimal\"] = 107] = \"NumpadDecimal\";\n    KeyCode[KeyCode[\"NumpadDivide\"] = 108] = \"NumpadDivide\";\n    /**\n     * Cover all key codes when IME is processing input.\n     */\n    KeyCode[KeyCode[\"KEY_IN_COMPOSITION\"] = 109] = \"KEY_IN_COMPOSITION\";\n    KeyCode[KeyCode[\"ABNT_C1\"] = 110] = \"ABNT_C1\";\n    KeyCode[KeyCode[\"ABNT_C2\"] = 111] = \"ABNT_C2\";\n    KeyCode[KeyCode[\"AudioVolumeMute\"] = 112] = \"AudioVolumeMute\";\n    KeyCode[KeyCode[\"AudioVolumeUp\"] = 113] = \"AudioVolumeUp\";\n    KeyCode[KeyCode[\"AudioVolumeDown\"] = 114] = \"AudioVolumeDown\";\n    KeyCode[KeyCode[\"BrowserSearch\"] = 115] = \"BrowserSearch\";\n    KeyCode[KeyCode[\"BrowserHome\"] = 116] = \"BrowserHome\";\n    KeyCode[KeyCode[\"BrowserBack\"] = 117] = \"BrowserBack\";\n    KeyCode[KeyCode[\"BrowserForward\"] = 118] = \"BrowserForward\";\n    KeyCode[KeyCode[\"MediaTrackNext\"] = 119] = \"MediaTrackNext\";\n    KeyCode[KeyCode[\"MediaTrackPrevious\"] = 120] = \"MediaTrackPrevious\";\n    KeyCode[KeyCode[\"MediaStop\"] = 121] = \"MediaStop\";\n    KeyCode[KeyCode[\"MediaPlayPause\"] = 122] = \"MediaPlayPause\";\n    KeyCode[KeyCode[\"LaunchMediaPlayer\"] = 123] = \"LaunchMediaPlayer\";\n    KeyCode[KeyCode[\"LaunchMail\"] = 124] = \"LaunchMail\";\n    KeyCode[KeyCode[\"LaunchApp2\"] = 125] = \"LaunchApp2\";\n    /**\n     * Placed last to cover the length of the enum.\n     * Please do not depend on this value!\n     */\n    KeyCode[KeyCode[\"MAX_VALUE\"] = 126] = \"MAX_VALUE\";\n})(KeyCode || (KeyCode = {}));\nexport var MarkerSeverity;\n(function (MarkerSeverity) {\n    MarkerSeverity[MarkerSeverity[\"Hint\"] = 1] = \"Hint\";\n    MarkerSeverity[MarkerSeverity[\"Info\"] = 2] = \"Info\";\n    MarkerSeverity[MarkerSeverity[\"Warning\"] = 4] = \"Warning\";\n    MarkerSeverity[MarkerSeverity[\"Error\"] = 8] = \"Error\";\n})(MarkerSeverity || (MarkerSeverity = {}));\nexport var MarkerTag;\n(function (MarkerTag) {\n    MarkerTag[MarkerTag[\"Unnecessary\"] = 1] = \"Unnecessary\";\n    MarkerTag[MarkerTag[\"Deprecated\"] = 2] = \"Deprecated\";\n})(MarkerTag || (MarkerTag = {}));\n/**\n * Position in the minimap to render the decoration.\n */\nexport var MinimapPosition;\n(function (MinimapPosition) {\n    MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\n    MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\n})(MinimapPosition || (MinimapPosition = {}));\n/**\n * Type of hit element with the mouse in the editor.\n */\nexport var MouseTargetType;\n(function (MouseTargetType) {\n    /**\n     * Mouse is on top of an unknown element.\n     */\n    MouseTargetType[MouseTargetType[\"UNKNOWN\"] = 0] = \"UNKNOWN\";\n    /**\n     * Mouse is on top of the textarea used for input.\n     */\n    MouseTargetType[MouseTargetType[\"TEXTAREA\"] = 1] = \"TEXTAREA\";\n    /**\n     * Mouse is on top of the glyph margin\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_GLYPH_MARGIN\"] = 2] = \"GUTTER_GLYPH_MARGIN\";\n    /**\n     * Mouse is on top of the line numbers\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_NUMBERS\"] = 3] = \"GUTTER_LINE_NUMBERS\";\n    /**\n     * Mouse is on top of the line decorations\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_LINE_DECORATIONS\"] = 4] = \"GUTTER_LINE_DECORATIONS\";\n    /**\n     * Mouse is on top of the whitespace left in the gutter by a view zone.\n     */\n    MouseTargetType[MouseTargetType[\"GUTTER_VIEW_ZONE\"] = 5] = \"GUTTER_VIEW_ZONE\";\n    /**\n     * Mouse is on top of text in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_TEXT\"] = 6] = \"CONTENT_TEXT\";\n    /**\n     * Mouse is on top of empty space in the content (e.g. after line text or below last line)\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_EMPTY\"] = 7] = \"CONTENT_EMPTY\";\n    /**\n     * Mouse is on top of a view zone in the content.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_VIEW_ZONE\"] = 8] = \"CONTENT_VIEW_ZONE\";\n    /**\n     * Mouse is on top of a content widget.\n     */\n    MouseTargetType[MouseTargetType[\"CONTENT_WIDGET\"] = 9] = \"CONTENT_WIDGET\";\n    /**\n     * Mouse is on top of the decorations overview ruler.\n     */\n    MouseTargetType[MouseTargetType[\"OVERVIEW_RULER\"] = 10] = \"OVERVIEW_RULER\";\n    /**\n     * Mouse is on top of a scrollbar.\n     */\n    MouseTargetType[MouseTargetType[\"SCROLLBAR\"] = 11] = \"SCROLLBAR\";\n    /**\n     * Mouse is on top of an overlay widget.\n     */\n    MouseTargetType[MouseTargetType[\"OVERLAY_WIDGET\"] = 12] = \"OVERLAY_WIDGET\";\n    /**\n     * Mouse is outside of the editor.\n     */\n    MouseTargetType[MouseTargetType[\"OUTSIDE_EDITOR\"] = 13] = \"OUTSIDE_EDITOR\";\n})(MouseTargetType || (MouseTargetType = {}));\n/**\n * A positioning preference for rendering overlay widgets.\n */\nexport var OverlayWidgetPositionPreference;\n(function (OverlayWidgetPositionPreference) {\n    /**\n     * Position the overlay widget in the top right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_RIGHT_CORNER\"] = 0] = \"TOP_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the bottom right corner\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"BOTTOM_RIGHT_CORNER\"] = 1] = \"BOTTOM_RIGHT_CORNER\";\n    /**\n     * Position the overlay widget in the top center\n     */\n    OverlayWidgetPositionPreference[OverlayWidgetPositionPreference[\"TOP_CENTER\"] = 2] = \"TOP_CENTER\";\n})(OverlayWidgetPositionPreference || (OverlayWidgetPositionPreference = {}));\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\nexport var RenderLineNumbersType;\n(function (RenderLineNumbersType) {\n    RenderLineNumbersType[RenderLineNumbersType[\"Off\"] = 0] = \"Off\";\n    RenderLineNumbersType[RenderLineNumbersType[\"On\"] = 1] = \"On\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Relative\"] = 2] = \"Relative\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Interval\"] = 3] = \"Interval\";\n    RenderLineNumbersType[RenderLineNumbersType[\"Custom\"] = 4] = \"Custom\";\n})(RenderLineNumbersType || (RenderLineNumbersType = {}));\nexport var RenderMinimap;\n(function (RenderMinimap) {\n    RenderMinimap[RenderMinimap[\"None\"] = 0] = \"None\";\n    RenderMinimap[RenderMinimap[\"Text\"] = 1] = \"Text\";\n    RenderMinimap[RenderMinimap[\"Blocks\"] = 2] = \"Blocks\";\n})(RenderMinimap || (RenderMinimap = {}));\nexport var ScrollType;\n(function (ScrollType) {\n    ScrollType[ScrollType[\"Smooth\"] = 0] = \"Smooth\";\n    ScrollType[ScrollType[\"Immediate\"] = 1] = \"Immediate\";\n})(ScrollType || (ScrollType = {}));\nexport var ScrollbarVisibility;\n(function (ScrollbarVisibility) {\n    ScrollbarVisibility[ScrollbarVisibility[\"Auto\"] = 1] = \"Auto\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Hidden\"] = 2] = \"Hidden\";\n    ScrollbarVisibility[ScrollbarVisibility[\"Visible\"] = 3] = \"Visible\";\n})(ScrollbarVisibility || (ScrollbarVisibility = {}));\n/**\n * The direction of a selection.\n */\nexport var SelectionDirection;\n(function (SelectionDirection) {\n    /**\n     * The selection starts above where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"LTR\"] = 0] = \"LTR\";\n    /**\n     * The selection starts below where it ends.\n     */\n    SelectionDirection[SelectionDirection[\"RTL\"] = 1] = \"RTL\";\n})(SelectionDirection || (SelectionDirection = {}));\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n    SymbolKind[SymbolKind[\"File\"] = 0] = \"File\";\n    SymbolKind[SymbolKind[\"Module\"] = 1] = \"Module\";\n    SymbolKind[SymbolKind[\"Namespace\"] = 2] = \"Namespace\";\n    SymbolKind[SymbolKind[\"Package\"] = 3] = \"Package\";\n    SymbolKind[SymbolKind[\"Class\"] = 4] = \"Class\";\n    SymbolKind[SymbolKind[\"Method\"] = 5] = \"Method\";\n    SymbolKind[SymbolKind[\"Property\"] = 6] = \"Property\";\n    SymbolKind[SymbolKind[\"Field\"] = 7] = \"Field\";\n    SymbolKind[SymbolKind[\"Constructor\"] = 8] = \"Constructor\";\n    SymbolKind[SymbolKind[\"Enum\"] = 9] = \"Enum\";\n    SymbolKind[SymbolKind[\"Interface\"] = 10] = \"Interface\";\n    SymbolKind[SymbolKind[\"Function\"] = 11] = \"Function\";\n    SymbolKind[SymbolKind[\"Variable\"] = 12] = \"Variable\";\n    SymbolKind[SymbolKind[\"Constant\"] = 13] = \"Constant\";\n    SymbolKind[SymbolKind[\"String\"] = 14] = \"String\";\n    SymbolKind[SymbolKind[\"Number\"] = 15] = \"Number\";\n    SymbolKind[SymbolKind[\"Boolean\"] = 16] = \"Boolean\";\n    SymbolKind[SymbolKind[\"Array\"] = 17] = \"Array\";\n    SymbolKind[SymbolKind[\"Object\"] = 18] = \"Object\";\n    SymbolKind[SymbolKind[\"Key\"] = 19] = \"Key\";\n    SymbolKind[SymbolKind[\"Null\"] = 20] = \"Null\";\n    SymbolKind[SymbolKind[\"EnumMember\"] = 21] = \"EnumMember\";\n    SymbolKind[SymbolKind[\"Struct\"] = 22] = \"Struct\";\n    SymbolKind[SymbolKind[\"Event\"] = 23] = \"Event\";\n    SymbolKind[SymbolKind[\"Operator\"] = 24] = \"Operator\";\n    SymbolKind[SymbolKind[\"TypeParameter\"] = 25] = \"TypeParameter\";\n})(SymbolKind || (SymbolKind = {}));\nexport var SymbolTag;\n(function (SymbolTag) {\n    SymbolTag[SymbolTag[\"Deprecated\"] = 1] = \"Deprecated\";\n})(SymbolTag || (SymbolTag = {}));\n/**\n * The kind of animation in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorBlinkingStyle;\n(function (TextEditorCursorBlinkingStyle) {\n    /**\n     * Hidden\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Hidden\"] = 0] = \"Hidden\";\n    /**\n     * Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Blink\"] = 1] = \"Blink\";\n    /**\n     * Blinking with smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Smooth\"] = 2] = \"Smooth\";\n    /**\n     * Blinking with prolonged filled state and smooth fading\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Phase\"] = 3] = \"Phase\";\n    /**\n     * Expand collapse animation on the y axis\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Expand\"] = 4] = \"Expand\";\n    /**\n     * No-Blinking\n     */\n    TextEditorCursorBlinkingStyle[TextEditorCursorBlinkingStyle[\"Solid\"] = 5] = \"Solid\";\n})(TextEditorCursorBlinkingStyle || (TextEditorCursorBlinkingStyle = {}));\n/**\n * The style in which the editor's cursor should be rendered.\n */\nexport var TextEditorCursorStyle;\n(function (TextEditorCursorStyle) {\n    /**\n     * As a vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Line\"] = 1] = \"Line\";\n    /**\n     * As a block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Block\"] = 2] = \"Block\";\n    /**\n     * As a horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"Underline\"] = 3] = \"Underline\";\n    /**\n     * As a thin vertical line (sitting between two characters).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"LineThin\"] = 4] = \"LineThin\";\n    /**\n     * As an outlined block (sitting on top of a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"BlockOutline\"] = 5] = \"BlockOutline\";\n    /**\n     * As a thin horizontal line (sitting under a character).\n     */\n    TextEditorCursorStyle[TextEditorCursorStyle[\"UnderlineThin\"] = 6] = \"UnderlineThin\";\n})(TextEditorCursorStyle || (TextEditorCursorStyle = {}));\n/**\n * Describes the behavior of decorations when typing/editing near their edges.\n * Note: Please do not edit the values, as they very carefully match `DecorationRangeBehavior`\n */\nexport var TrackedRangeStickiness;\n(function (TrackedRangeStickiness) {\n    TrackedRangeStickiness[TrackedRangeStickiness[\"AlwaysGrowsWhenTypingAtEdges\"] = 0] = \"AlwaysGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"NeverGrowsWhenTypingAtEdges\"] = 1] = \"NeverGrowsWhenTypingAtEdges\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingBefore\"] = 2] = \"GrowsOnlyWhenTypingBefore\";\n    TrackedRangeStickiness[TrackedRangeStickiness[\"GrowsOnlyWhenTypingAfter\"] = 3] = \"GrowsOnlyWhenTypingAfter\";\n})(TrackedRangeStickiness || (TrackedRangeStickiness = {}));\n/**\n * Describes how to indent wrapped lines.\n */\nexport var WrappingIndent;\n(function (WrappingIndent) {\n    /**\n     * No indentation => wrapped lines begin at column 1.\n     */\n    WrappingIndent[WrappingIndent[\"None\"] = 0] = \"None\";\n    /**\n     * Same => wrapped lines get the same indentation as the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Same\"] = 1] = \"Same\";\n    /**\n     * Indent => wrapped lines get +1 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"Indent\"] = 2] = \"Indent\";\n    /**\n     * DeepIndent => wrapped lines get +2 indentation toward the parent.\n     */\n    WrappingIndent[WrappingIndent[\"DeepIndent\"] = 3] = \"DeepIndent\";\n})(WrappingIndent || (WrappingIndent = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport class Selection extends Range {\n    constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n        super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);\n        this.selectionStartLineNumber = selectionStartLineNumber;\n        this.selectionStartColumn = selectionStartColumn;\n        this.positionLineNumber = positionLineNumber;\n        this.positionColumn = positionColumn;\n    }\n    /**\n     * Transform to a human-readable representation.\n     */\n    toString() {\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n    }\n    /**\n     * Test if equals other selection.\n     */\n    equalsSelection(other) {\n        return (Selection.selectionsEqual(this, other));\n    }\n    /**\n     * Test if the two selections are equal.\n     */\n    static selectionsEqual(a, b) {\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n            a.selectionStartColumn === b.selectionStartColumn &&\n            a.positionLineNumber === b.positionLineNumber &&\n            a.positionColumn === b.positionColumn);\n    }\n    /**\n     * Get directions (LTR or RTL).\n     */\n    getDirection() {\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n            return 0 /* LTR */;\n        }\n        return 1 /* RTL */;\n    }\n    /**\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n    }\n    /**\n     * Get the position at `positionLineNumber` and `positionColumn`.\n     */\n    getPosition() {\n        return new Position(this.positionLineNumber, this.positionColumn);\n    }\n    /**\n     * Get the position at the start of the selection.\n    */\n    getSelectionStart() {\n        return new Position(this.selectionStartLineNumber, this.selectionStartColumn);\n    }\n    /**\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        if (this.getDirection() === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n        }\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n    }\n    // ----\n    /**\n     * Create a `Selection` from one or two positions\n     */\n    static fromPositions(start, end = start) {\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    /**\n     * Creates a `Selection` from a range, given a direction.\n     */\n    static fromRange(range, direction) {\n        if (direction === 0 /* LTR */) {\n            return new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n        }\n        else {\n            return new Selection(range.endLineNumber, range.endColumn, range.startLineNumber, range.startColumn);\n        }\n    }\n    /**\n     * Create a `Selection` from an `ISelection`.\n     */\n    static liftSelection(sel) {\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n    }\n    /**\n     * `a` equals `b`.\n     */\n    static selectionsArrEqual(a, b) {\n        if (a && !b || !a && b) {\n            return false;\n        }\n        if (!a && !b) {\n            return true;\n        }\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (let i = 0, len = a.length; i < len; i++) {\n            if (!this.selectionsEqual(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Test if `obj` is an `ISelection`.\n     */\n    static isISelection(obj) {\n        return (obj\n            && (typeof obj.selectionStartLineNumber === 'number')\n            && (typeof obj.selectionStartColumn === 'number')\n            && (typeof obj.positionLineNumber === 'number')\n            && (typeof obj.positionColumn === 'number'));\n    }\n    /**\n     * Create with a direction.\n     */\n    static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n        if (direction === 0 /* LTR */) {\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Token {\n    constructor(offset, type, language) {\n        this._tokenBrand = undefined;\n        this.offset = offset;\n        this.type = type;\n        this.language = language;\n    }\n    toString() {\n        return '(' + this.offset + ', ' + this.type + ')';\n    }\n}\nexport class TokenizationResult {\n    constructor(tokens, endState) {\n        this._tokenizationResultBrand = undefined;\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n}\nexport class TokenizationResult2 {\n    constructor(tokens, endState) {\n        this._tokenizationResult2Brand = undefined;\n        this.tokens = tokens;\n        this.endState = endState;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CancellationTokenSource } from '../../../base/common/cancellation.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { KeyChord } from '../../../base/common/keyCodes.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { Token } from '../core/token.js';\nimport * as standaloneEnums from './standaloneEnums.js';\nexport class KeyMod {\n    static chord(firstPart, secondPart) {\n        return KeyChord(firstPart, secondPart);\n    }\n}\nKeyMod.CtrlCmd = 2048 /* CtrlCmd */;\nKeyMod.Shift = 1024 /* Shift */;\nKeyMod.Alt = 512 /* Alt */;\nKeyMod.WinCtrl = 256 /* WinCtrl */;\nexport function createMonacoBaseAPI() {\n    return {\n        editor: undefined,\n        languages: undefined,\n        CancellationTokenSource: CancellationTokenSource,\n        Emitter: Emitter,\n        KeyCode: standaloneEnums.KeyCode,\n        KeyMod: KeyMod,\n        Position: Position,\n        Range: Range,\n        Selection: Selection,\n        SelectionDirection: standaloneEnums.SelectionDirection,\n        MarkerSeverity: standaloneEnums.MarkerSeverity,\n        MarkerTag: standaloneEnums.MarkerTag,\n        Uri: URI,\n        Token: Token\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nexport class WordCharacterClassifier extends CharacterClassifier {\n    constructor(wordSeparators) {\n        super(0 /* Regular */);\n        for (let i = 0, len = wordSeparators.length; i < len; i++) {\n            this.set(wordSeparators.charCodeAt(i), 2 /* WordSeparator */);\n        }\n        this.set(32 /* Space */, 1 /* Whitespace */);\n        this.set(9 /* Tab */, 1 /* Whitespace */);\n    }\n}\nfunction once(computeFn) {\n    let cache = {}; // TODO@Alex unbounded cache\n    return (input) => {\n        if (!cache.hasOwnProperty(input)) {\n            cache[input] = computeFn(input);\n        }\n        return cache[input];\n    };\n}\nexport const getMapForWordSeparators = once((input) => new WordCharacterClassifier(input));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { isArray, isObject, isUndefinedOrNull } from './types.js';\nexport function deepClone(obj) {\n    if (!obj || typeof obj !== 'object') {\n        return obj;\n    }\n    if (obj instanceof RegExp) {\n        // See https://github.com/microsoft/TypeScript/issues/10990\n        return obj;\n    }\n    const result = Array.isArray(obj) ? [] : {};\n    Object.keys(obj).forEach((key) => {\n        if (obj[key] && typeof obj[key] === 'object') {\n            result[key] = deepClone(obj[key]);\n        }\n        else {\n            result[key] = obj[key];\n        }\n    });\n    return result;\n}\nexport function deepFreeze(obj) {\n    if (!obj || typeof obj !== 'object') {\n        return obj;\n    }\n    const stack = [obj];\n    while (stack.length > 0) {\n        const obj = stack.shift();\n        Object.freeze(obj);\n        for (const key in obj) {\n            if (_hasOwnProperty.call(obj, key)) {\n                const prop = obj[key];\n                if (typeof prop === 'object' && !Object.isFrozen(prop)) {\n                    stack.push(prop);\n                }\n            }\n        }\n    }\n    return obj;\n}\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function cloneAndChange(obj, changer) {\n    return _cloneAndChange(obj, changer, new Set());\n}\nfunction _cloneAndChange(obj, changer, seen) {\n    if (isUndefinedOrNull(obj)) {\n        return obj;\n    }\n    const changed = changer(obj);\n    if (typeof changed !== 'undefined') {\n        return changed;\n    }\n    if (isArray(obj)) {\n        const r1 = [];\n        for (const e of obj) {\n            r1.push(_cloneAndChange(e, changer, seen));\n        }\n        return r1;\n    }\n    if (isObject(obj)) {\n        if (seen.has(obj)) {\n            throw new Error('Cannot clone recursive data-structure');\n        }\n        seen.add(obj);\n        const r2 = {};\n        for (let i2 in obj) {\n            if (_hasOwnProperty.call(obj, i2)) {\n                r2[i2] = _cloneAndChange(obj[i2], changer, seen);\n            }\n        }\n        seen.delete(obj);\n        return r2;\n    }\n    return obj;\n}\n/**\n * Copies all properties of source into destination. The optional parameter \"overwrite\" allows to control\n * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).\n */\nexport function mixin(destination, source, overwrite = true) {\n    if (!isObject(destination)) {\n        return source;\n    }\n    if (isObject(source)) {\n        Object.keys(source).forEach(key => {\n            if (key in destination) {\n                if (overwrite) {\n                    if (isObject(destination[key]) && isObject(source[key])) {\n                        mixin(destination[key], source[key], overwrite);\n                    }\n                    else {\n                        destination[key] = source[key];\n                    }\n                }\n            }\n            else {\n                destination[key] = source[key];\n            }\n        });\n    }\n    return destination;\n}\nexport function equals(one, other) {\n    if (one === other) {\n        return true;\n    }\n    if (one === null || one === undefined || other === null || other === undefined) {\n        return false;\n    }\n    if (typeof one !== typeof other) {\n        return false;\n    }\n    if (typeof one !== 'object') {\n        return false;\n    }\n    if ((Array.isArray(one)) !== (Array.isArray(other))) {\n        return false;\n    }\n    let i;\n    let key;\n    if (Array.isArray(one)) {\n        if (one.length !== other.length) {\n            return false;\n        }\n        for (i = 0; i < one.length; i++) {\n            if (!equals(one[i], other[i])) {\n                return false;\n            }\n        }\n    }\n    else {\n        const oneKeys = [];\n        for (key in one) {\n            oneKeys.push(key);\n        }\n        oneKeys.sort();\n        const otherKeys = [];\n        for (key in other) {\n            otherKeys.push(key);\n        }\n        otherKeys.sort();\n        if (!equals(oneKeys, otherKeys)) {\n            return false;\n        }\n        for (i = 0; i < oneKeys.length; i++) {\n            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\nexport function getOrDefault(obj, fn, defaultValue) {\n    const result = fn(obj);\n    return typeof result === 'undefined' ? defaultValue : result;\n}\n","import { equals } from '../../base/common/objects.js';\n/**\n * Vertical Lane in the overview ruler of the editor.\n */\nexport var OverviewRulerLane;\n(function (OverviewRulerLane) {\n    OverviewRulerLane[OverviewRulerLane[\"Left\"] = 1] = \"Left\";\n    OverviewRulerLane[OverviewRulerLane[\"Center\"] = 2] = \"Center\";\n    OverviewRulerLane[OverviewRulerLane[\"Right\"] = 4] = \"Right\";\n    OverviewRulerLane[OverviewRulerLane[\"Full\"] = 7] = \"Full\";\n})(OverviewRulerLane || (OverviewRulerLane = {}));\n/**\n * Position in the minimap to render the decoration.\n */\nexport var MinimapPosition;\n(function (MinimapPosition) {\n    MinimapPosition[MinimapPosition[\"Inline\"] = 1] = \"Inline\";\n    MinimapPosition[MinimapPosition[\"Gutter\"] = 2] = \"Gutter\";\n})(MinimapPosition || (MinimapPosition = {}));\nexport class TextModelResolvedOptions {\n    /**\n     * @internal\n     */\n    constructor(src) {\n        this._textModelResolvedOptionsBrand = undefined;\n        this.tabSize = Math.max(1, src.tabSize | 0);\n        this.indentSize = src.tabSize | 0;\n        this.insertSpaces = Boolean(src.insertSpaces);\n        this.defaultEOL = src.defaultEOL | 0;\n        this.trimAutoWhitespace = Boolean(src.trimAutoWhitespace);\n        this.bracketPairColorizationOptions = src.bracketPairColorizationOptions;\n    }\n    /**\n     * @internal\n     */\n    equals(other) {\n        return (this.tabSize === other.tabSize\n            && this.indentSize === other.indentSize\n            && this.insertSpaces === other.insertSpaces\n            && this.defaultEOL === other.defaultEOL\n            && this.trimAutoWhitespace === other.trimAutoWhitespace\n            && equals(this.bracketPairColorizationOptions, other.bracketPairColorizationOptions));\n    }\n    /**\n     * @internal\n     */\n    createChangeEvent(newOpts) {\n        return {\n            tabSize: this.tabSize !== newOpts.tabSize,\n            indentSize: this.indentSize !== newOpts.indentSize,\n            insertSpaces: this.insertSpaces !== newOpts.insertSpaces,\n            trimAutoWhitespace: this.trimAutoWhitespace !== newOpts.trimAutoWhitespace,\n        };\n    }\n}\nexport class FindMatch {\n    /**\n     * @internal\n     */\n    constructor(range, matches) {\n        this._findMatchBrand = undefined;\n        this.range = range;\n        this.matches = matches;\n    }\n}\n/**\n * @internal\n */\nexport var HorizontalGuidesState;\n(function (HorizontalGuidesState) {\n    HorizontalGuidesState[HorizontalGuidesState[\"Disabled\"] = 0] = \"Disabled\";\n    HorizontalGuidesState[HorizontalGuidesState[\"EnabledForActive\"] = 1] = \"EnabledForActive\";\n    HorizontalGuidesState[HorizontalGuidesState[\"Enabled\"] = 2] = \"Enabled\";\n})(HorizontalGuidesState || (HorizontalGuidesState = {}));\n/**\n * @internal\n */\nexport class IndentGuide {\n    constructor(visibleColumn, className, \n    /**\n     * If set, this indent guide is a horizontal guide (no vertical part).\n     * It starts at visibleColumn and continues until endColumn.\n    */\n    horizontalLine) {\n        this.visibleColumn = visibleColumn;\n        this.className = className;\n        this.horizontalLine = horizontalLine;\n    }\n}\n/**\n * @internal\n */\nexport class IndentGuideHorizontalLine {\n    constructor(top, endColumn) {\n        this.top = top;\n        this.endColumn = endColumn;\n    }\n}\n/**\n * @internal\n */\nexport class ValidAnnotatedEditOperation {\n    constructor(identifier, range, text, forceMoveMarkers, isAutoWhitespaceEdit, _isTracked) {\n        this.identifier = identifier;\n        this.range = range;\n        this.text = text;\n        this.forceMoveMarkers = forceMoveMarkers;\n        this.isAutoWhitespaceEdit = isAutoWhitespaceEdit;\n        this._isTracked = _isTracked;\n    }\n}\n/**\n * @internal\n */\nexport class ApplyEditsResult {\n    constructor(reverseEdits, changes, trimAutoWhitespaceLineNumbers) {\n        this.reverseEdits = reverseEdits;\n        this.changes = changes;\n        this.trimAutoWhitespaceLineNumbers = trimAutoWhitespaceLineNumbers;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { getMapForWordSeparators } from '../controller/wordCharacterClassifier.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { FindMatch } from '../model.js';\nconst LIMIT_FIND_COUNT = 999;\nexport class SearchParams {\n    constructor(searchString, isRegex, matchCase, wordSeparators) {\n        this.searchString = searchString;\n        this.isRegex = isRegex;\n        this.matchCase = matchCase;\n        this.wordSeparators = wordSeparators;\n    }\n    parseSearchRequest() {\n        if (this.searchString === '') {\n            return null;\n        }\n        // Try to create a RegExp out of the params\n        let multiline;\n        if (this.isRegex) {\n            multiline = isMultilineRegexSource(this.searchString);\n        }\n        else {\n            multiline = (this.searchString.indexOf('\\n') >= 0);\n        }\n        let regex = null;\n        try {\n            regex = strings.createRegExp(this.searchString, this.isRegex, {\n                matchCase: this.matchCase,\n                wholeWord: false,\n                multiline: multiline,\n                global: true,\n                unicode: true\n            });\n        }\n        catch (err) {\n            return null;\n        }\n        if (!regex) {\n            return null;\n        }\n        let canUseSimpleSearch = (!this.isRegex && !multiline);\n        if (canUseSimpleSearch && this.searchString.toLowerCase() !== this.searchString.toUpperCase()) {\n            // casing might make a difference\n            canUseSimpleSearch = this.matchCase;\n        }\n        return new SearchData(regex, this.wordSeparators ? getMapForWordSeparators(this.wordSeparators) : null, canUseSimpleSearch ? this.searchString : null);\n    }\n}\nexport function isMultilineRegexSource(searchString) {\n    if (!searchString || searchString.length === 0) {\n        return false;\n    }\n    for (let i = 0, len = searchString.length; i < len; i++) {\n        const chCode = searchString.charCodeAt(i);\n        if (chCode === 92 /* Backslash */) {\n            // move to next char\n            i++;\n            if (i >= len) {\n                // string ends with a \\\n                break;\n            }\n            const nextChCode = searchString.charCodeAt(i);\n            if (nextChCode === 110 /* n */ || nextChCode === 114 /* r */ || nextChCode === 87 /* W */) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\nexport class SearchData {\n    constructor(regex, wordSeparators, simpleSearch) {\n        this.regex = regex;\n        this.wordSeparators = wordSeparators;\n        this.simpleSearch = simpleSearch;\n    }\n}\nexport function createFindMatch(range, rawMatches, captureMatches) {\n    if (!captureMatches) {\n        return new FindMatch(range, null);\n    }\n    let matches = [];\n    for (let i = 0, len = rawMatches.length; i < len; i++) {\n        matches[i] = rawMatches[i];\n    }\n    return new FindMatch(range, matches);\n}\nclass LineFeedCounter {\n    constructor(text) {\n        let lineFeedsOffsets = [];\n        let lineFeedsOffsetsLen = 0;\n        for (let i = 0, textLen = text.length; i < textLen; i++) {\n            if (text.charCodeAt(i) === 10 /* LineFeed */) {\n                lineFeedsOffsets[lineFeedsOffsetsLen++] = i;\n            }\n        }\n        this._lineFeedsOffsets = lineFeedsOffsets;\n    }\n    findLineFeedCountBeforeOffset(offset) {\n        const lineFeedsOffsets = this._lineFeedsOffsets;\n        let min = 0;\n        let max = lineFeedsOffsets.length - 1;\n        if (max === -1) {\n            // no line feeds\n            return 0;\n        }\n        if (offset <= lineFeedsOffsets[0]) {\n            // before first line feed\n            return 0;\n        }\n        while (min < max) {\n            const mid = min + ((max - min) / 2 >> 0);\n            if (lineFeedsOffsets[mid] >= offset) {\n                max = mid - 1;\n            }\n            else {\n                if (lineFeedsOffsets[mid + 1] >= offset) {\n                    // bingo!\n                    min = mid;\n                    max = mid;\n                }\n                else {\n                    min = mid + 1;\n                }\n            }\n        }\n        return min + 1;\n    }\n}\nexport class TextModelSearch {\n    static findMatches(model, searchParams, searchRange, captureMatches, limitResultCount) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return [];\n        }\n        if (searchData.regex.multiline) {\n            return this._doFindMatchesMultiline(model, searchRange, new Searcher(searchData.wordSeparators, searchData.regex), captureMatches, limitResultCount);\n        }\n        return this._doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount);\n    }\n    /**\n     * Multiline search always executes on the lines concatenated with \\n.\n     * We must therefore compensate for the count of \\n in case the model is CRLF\n     */\n    static _getMultilineMatchRange(model, deltaOffset, text, lfCounter, matchIndex, match0) {\n        let startOffset;\n        let lineFeedCountBeforeMatch = 0;\n        if (lfCounter) {\n            lineFeedCountBeforeMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex);\n            startOffset = deltaOffset + matchIndex + lineFeedCountBeforeMatch /* add as many \\r as there were \\n */;\n        }\n        else {\n            startOffset = deltaOffset + matchIndex;\n        }\n        let endOffset;\n        if (lfCounter) {\n            let lineFeedCountBeforeEndOfMatch = lfCounter.findLineFeedCountBeforeOffset(matchIndex + match0.length);\n            let lineFeedCountInMatch = lineFeedCountBeforeEndOfMatch - lineFeedCountBeforeMatch;\n            endOffset = startOffset + match0.length + lineFeedCountInMatch /* add as many \\r as there were \\n */;\n        }\n        else {\n            endOffset = startOffset + match0.length;\n        }\n        const startPosition = model.getPositionAt(startOffset);\n        const endPosition = model.getPositionAt(endOffset);\n        return new Range(startPosition.lineNumber, startPosition.column, endPosition.lineNumber, endPosition.column);\n    }\n    static _doFindMatchesMultiline(model, searchRange, searcher, captureMatches, limitResultCount) {\n        const deltaOffset = model.getOffsetAt(searchRange.getStartPosition());\n        // We always execute multiline search over the lines joined with \\n\n        // This makes it that \\n will match the EOL for both CRLF and LF models\n        // We compensate for offset errors in `_getMultilineMatchRange`\n        const text = model.getValueInRange(searchRange, 1 /* LF */);\n        const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n        const result = [];\n        let counter = 0;\n        let m;\n        searcher.reset(0);\n        while ((m = searcher.next(text))) {\n            result[counter++] = createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n            if (counter >= limitResultCount) {\n                return result;\n            }\n        }\n        return result;\n    }\n    static _doFindMatchesLineByLine(model, searchRange, searchData, captureMatches, limitResultCount) {\n        const result = [];\n        let resultLen = 0;\n        // Early case for a search range that starts & stops on the same line number\n        if (searchRange.startLineNumber === searchRange.endLineNumber) {\n            const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1, searchRange.endColumn - 1);\n            resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n            return result;\n        }\n        // Collect results from first line\n        const text = model.getLineContent(searchRange.startLineNumber).substring(searchRange.startColumn - 1);\n        resultLen = this._findMatchesInLine(searchData, text, searchRange.startLineNumber, searchRange.startColumn - 1, resultLen, result, captureMatches, limitResultCount);\n        // Collect results from middle lines\n        for (let lineNumber = searchRange.startLineNumber + 1; lineNumber < searchRange.endLineNumber && resultLen < limitResultCount; lineNumber++) {\n            resultLen = this._findMatchesInLine(searchData, model.getLineContent(lineNumber), lineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n        }\n        // Collect results from last line\n        if (resultLen < limitResultCount) {\n            const text = model.getLineContent(searchRange.endLineNumber).substring(0, searchRange.endColumn - 1);\n            resultLen = this._findMatchesInLine(searchData, text, searchRange.endLineNumber, 0, resultLen, result, captureMatches, limitResultCount);\n        }\n        return result;\n    }\n    static _findMatchesInLine(searchData, text, lineNumber, deltaOffset, resultLen, result, captureMatches, limitResultCount) {\n        const wordSeparators = searchData.wordSeparators;\n        if (!captureMatches && searchData.simpleSearch) {\n            const searchString = searchData.simpleSearch;\n            const searchStringLen = searchString.length;\n            const textLength = text.length;\n            let lastMatchIndex = -searchStringLen;\n            while ((lastMatchIndex = text.indexOf(searchString, lastMatchIndex + searchStringLen)) !== -1) {\n                if (!wordSeparators || isValidMatch(wordSeparators, text, textLength, lastMatchIndex, searchStringLen)) {\n                    result[resultLen++] = new FindMatch(new Range(lineNumber, lastMatchIndex + 1 + deltaOffset, lineNumber, lastMatchIndex + 1 + searchStringLen + deltaOffset), null);\n                    if (resultLen >= limitResultCount) {\n                        return resultLen;\n                    }\n                }\n            }\n            return resultLen;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        let m;\n        // Reset regex to search from the beginning\n        searcher.reset(0);\n        do {\n            m = searcher.next(text);\n            if (m) {\n                result[resultLen++] = createFindMatch(new Range(lineNumber, m.index + 1 + deltaOffset, lineNumber, m.index + 1 + m[0].length + deltaOffset), m, captureMatches);\n                if (resultLen >= limitResultCount) {\n                    return resultLen;\n                }\n            }\n        } while (m);\n        return resultLen;\n    }\n    static findNextMatch(model, searchParams, searchStart, captureMatches) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return null;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        if (searchData.regex.multiline) {\n            return this._doFindNextMatchMultiline(model, searchStart, searcher, captureMatches);\n        }\n        return this._doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches);\n    }\n    static _doFindNextMatchMultiline(model, searchStart, searcher, captureMatches) {\n        const searchTextStart = new Position(searchStart.lineNumber, 1);\n        const deltaOffset = model.getOffsetAt(searchTextStart);\n        const lineCount = model.getLineCount();\n        // We always execute multiline search over the lines joined with \\n\n        // This makes it that \\n will match the EOL for both CRLF and LF models\n        // We compensate for offset errors in `_getMultilineMatchRange`\n        const text = model.getValueInRange(new Range(searchTextStart.lineNumber, searchTextStart.column, lineCount, model.getLineMaxColumn(lineCount)), 1 /* LF */);\n        const lfCounter = (model.getEOL() === '\\r\\n' ? new LineFeedCounter(text) : null);\n        searcher.reset(searchStart.column - 1);\n        let m = searcher.next(text);\n        if (m) {\n            return createFindMatch(this._getMultilineMatchRange(model, deltaOffset, text, lfCounter, m.index, m[0]), m, captureMatches);\n        }\n        if (searchStart.lineNumber !== 1 || searchStart.column !== 1) {\n            // Try again from the top\n            return this._doFindNextMatchMultiline(model, new Position(1, 1), searcher, captureMatches);\n        }\n        return null;\n    }\n    static _doFindNextMatchLineByLine(model, searchStart, searcher, captureMatches) {\n        const lineCount = model.getLineCount();\n        const startLineNumber = searchStart.lineNumber;\n        // Look in first line\n        const text = model.getLineContent(startLineNumber);\n        const r = this._findFirstMatchInLine(searcher, text, startLineNumber, searchStart.column, captureMatches);\n        if (r) {\n            return r;\n        }\n        for (let i = 1; i <= lineCount; i++) {\n            const lineIndex = (startLineNumber + i - 1) % lineCount;\n            const text = model.getLineContent(lineIndex + 1);\n            const r = this._findFirstMatchInLine(searcher, text, lineIndex + 1, 1, captureMatches);\n            if (r) {\n                return r;\n            }\n        }\n        return null;\n    }\n    static _findFirstMatchInLine(searcher, text, lineNumber, fromColumn, captureMatches) {\n        // Set regex to search from column\n        searcher.reset(fromColumn - 1);\n        const m = searcher.next(text);\n        if (m) {\n            return createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n        }\n        return null;\n    }\n    static findPreviousMatch(model, searchParams, searchStart, captureMatches) {\n        const searchData = searchParams.parseSearchRequest();\n        if (!searchData) {\n            return null;\n        }\n        const searcher = new Searcher(searchData.wordSeparators, searchData.regex);\n        if (searchData.regex.multiline) {\n            return this._doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches);\n        }\n        return this._doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches);\n    }\n    static _doFindPreviousMatchMultiline(model, searchStart, searcher, captureMatches) {\n        const matches = this._doFindMatchesMultiline(model, new Range(1, 1, searchStart.lineNumber, searchStart.column), searcher, captureMatches, 10 * LIMIT_FIND_COUNT);\n        if (matches.length > 0) {\n            return matches[matches.length - 1];\n        }\n        const lineCount = model.getLineCount();\n        if (searchStart.lineNumber !== lineCount || searchStart.column !== model.getLineMaxColumn(lineCount)) {\n            // Try again with all content\n            return this._doFindPreviousMatchMultiline(model, new Position(lineCount, model.getLineMaxColumn(lineCount)), searcher, captureMatches);\n        }\n        return null;\n    }\n    static _doFindPreviousMatchLineByLine(model, searchStart, searcher, captureMatches) {\n        const lineCount = model.getLineCount();\n        const startLineNumber = searchStart.lineNumber;\n        // Look in first line\n        const text = model.getLineContent(startLineNumber).substring(0, searchStart.column - 1);\n        const r = this._findLastMatchInLine(searcher, text, startLineNumber, captureMatches);\n        if (r) {\n            return r;\n        }\n        for (let i = 1; i <= lineCount; i++) {\n            const lineIndex = (lineCount + startLineNumber - i - 1) % lineCount;\n            const text = model.getLineContent(lineIndex + 1);\n            const r = this._findLastMatchInLine(searcher, text, lineIndex + 1, captureMatches);\n            if (r) {\n                return r;\n            }\n        }\n        return null;\n    }\n    static _findLastMatchInLine(searcher, text, lineNumber, captureMatches) {\n        let bestResult = null;\n        let m;\n        searcher.reset(0);\n        while ((m = searcher.next(text))) {\n            bestResult = createFindMatch(new Range(lineNumber, m.index + 1, lineNumber, m.index + 1 + m[0].length), m, captureMatches);\n        }\n        return bestResult;\n    }\n}\nfunction leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    if (matchStartIndex === 0) {\n        // Match starts at start of string\n        return true;\n    }\n    const charBefore = text.charCodeAt(matchStartIndex - 1);\n    if (wordSeparators.get(charBefore) !== 0 /* Regular */) {\n        // The character before the match is a word separator\n        return true;\n    }\n    if (charBefore === 13 /* CarriageReturn */ || charBefore === 10 /* LineFeed */) {\n        // The character before the match is line break or carriage return.\n        return true;\n    }\n    if (matchLength > 0) {\n        const firstCharInMatch = text.charCodeAt(matchStartIndex);\n        if (wordSeparators.get(firstCharInMatch) !== 0 /* Regular */) {\n            // The first character inside the match is a word separator\n            return true;\n        }\n    }\n    return false;\n}\nfunction rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    if (matchStartIndex + matchLength === textLength) {\n        // Match ends at end of string\n        return true;\n    }\n    const charAfter = text.charCodeAt(matchStartIndex + matchLength);\n    if (wordSeparators.get(charAfter) !== 0 /* Regular */) {\n        // The character after the match is a word separator\n        return true;\n    }\n    if (charAfter === 13 /* CarriageReturn */ || charAfter === 10 /* LineFeed */) {\n        // The character after the match is line break or carriage return.\n        return true;\n    }\n    if (matchLength > 0) {\n        const lastCharInMatch = text.charCodeAt(matchStartIndex + matchLength - 1);\n        if (wordSeparators.get(lastCharInMatch) !== 0 /* Regular */) {\n            // The last character in the match is a word separator\n            return true;\n        }\n    }\n    return false;\n}\nexport function isValidMatch(wordSeparators, text, textLength, matchStartIndex, matchLength) {\n    return (leftIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength)\n        && rightIsWordBounday(wordSeparators, text, textLength, matchStartIndex, matchLength));\n}\nexport class Searcher {\n    constructor(wordSeparators, searchRegex) {\n        this._wordSeparators = wordSeparators;\n        this._searchRegex = searchRegex;\n        this._prevMatchStartIndex = -1;\n        this._prevMatchLength = 0;\n    }\n    reset(lastIndex) {\n        this._searchRegex.lastIndex = lastIndex;\n        this._prevMatchStartIndex = -1;\n        this._prevMatchLength = 0;\n    }\n    next(text) {\n        const textLength = text.length;\n        let m;\n        do {\n            if (this._prevMatchStartIndex + this._prevMatchLength === textLength) {\n                // Reached the end of the line\n                return null;\n            }\n            m = this._searchRegex.exec(text);\n            if (!m) {\n                return null;\n            }\n            const matchStartIndex = m.index;\n            const matchLength = m[0].length;\n            if (matchStartIndex === this._prevMatchStartIndex && matchLength === this._prevMatchLength) {\n                if (matchLength === 0) {\n                    // the search result is an empty string and won't advance `regex.lastIndex`, so `regex.exec` will stuck here\n                    // we attempt to recover from that by advancing by two if surrogate pair found and by one otherwise\n                    if (strings.getNextCodePoint(text, textLength, this._searchRegex.lastIndex) > 0xFFFF) {\n                        this._searchRegex.lastIndex += 2;\n                    }\n                    else {\n                        this._searchRegex.lastIndex += 1;\n                    }\n                    continue;\n                }\n                // Exit early if the regex matches the same range twice\n                return null;\n            }\n            this._prevMatchStartIndex = matchStartIndex;\n            this._prevMatchLength = matchLength;\n            if (!this._wordSeparators || isValidMatch(this._wordSeparators, text, textLength, matchStartIndex, matchLength)) {\n                return m;\n            }\n        } while (m);\n        return null;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Range } from '../core/range.js';\nimport { Searcher } from '../model/textModelSearch.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { assertNever } from '../../../base/common/types.js';\nexport class UnicodeTextModelHighlighter {\n    static computeUnicodeHighlights(model, options, range) {\n        const startLine = range ? range.startLineNumber : 1;\n        const endLine = range ? range.endLineNumber : model.getLineCount();\n        const codePointHighlighter = new CodePointHighlighter(options);\n        const candidates = codePointHighlighter.getCandidateCodePoints();\n        let regex;\n        if (candidates === 'allNonBasicAscii') {\n            regex = new RegExp('[^\\\\t\\\\n\\\\r\\\\x20-\\\\x7E]', 'g');\n        }\n        else {\n            regex = new RegExp(`${buildRegExpCharClassExpr(Array.from(candidates))}`, 'g');\n        }\n        const searcher = new Searcher(null, regex);\n        const ranges = [];\n        let hasMore = false;\n        let m;\n        let ambiguousCharacterCount = 0;\n        let invisibleCharacterCount = 0;\n        let nonBasicAsciiCharacterCount = 0;\n        forLoop: for (let lineNumber = startLine, lineCount = endLine; lineNumber <= lineCount; lineNumber++) {\n            const lineContent = model.getLineContent(lineNumber);\n            const lineLength = lineContent.length;\n            // Reset regex to search from the beginning\n            searcher.reset(0);\n            do {\n                m = searcher.next(lineContent);\n                if (m) {\n                    let startIndex = m.index;\n                    let endIndex = m.index + m[0].length;\n                    // Extend range to entire code point\n                    if (startIndex > 0) {\n                        const charCodeBefore = lineContent.charCodeAt(startIndex - 1);\n                        if (strings.isHighSurrogate(charCodeBefore)) {\n                            startIndex--;\n                        }\n                    }\n                    if (endIndex + 1 < lineLength) {\n                        const charCodeBefore = lineContent.charCodeAt(endIndex - 1);\n                        if (strings.isHighSurrogate(charCodeBefore)) {\n                            endIndex++;\n                        }\n                    }\n                    const str = lineContent.substring(startIndex, endIndex);\n                    const highlightReason = codePointHighlighter.shouldHighlightNonBasicASCII(str);\n                    if (highlightReason !== 0 /* None */) {\n                        if (highlightReason === 3 /* Ambiguous */) {\n                            ambiguousCharacterCount++;\n                        }\n                        else if (highlightReason === 2 /* Invisible */) {\n                            invisibleCharacterCount++;\n                        }\n                        else if (highlightReason === 1 /* NonBasicASCII */) {\n                            nonBasicAsciiCharacterCount++;\n                        }\n                        else {\n                            assertNever(highlightReason);\n                        }\n                        const MAX_RESULT_LENGTH = 1000;\n                        if (ranges.length >= MAX_RESULT_LENGTH) {\n                            hasMore = true;\n                            break forLoop;\n                        }\n                        ranges.push(new Range(lineNumber, startIndex + 1, lineNumber, endIndex + 1));\n                    }\n                }\n            } while (m);\n        }\n        return {\n            ranges,\n            hasMore,\n            ambiguousCharacterCount,\n            invisibleCharacterCount,\n            nonBasicAsciiCharacterCount\n        };\n    }\n    static computeUnicodeHighlightReason(char, options) {\n        const codePointHighlighter = new CodePointHighlighter(options);\n        const reason = codePointHighlighter.shouldHighlightNonBasicASCII(char);\n        switch (reason) {\n            case 0 /* None */:\n                return null;\n            case 2 /* Invisible */:\n                return { kind: 1 /* Invisible */ };\n            case 3 /* Ambiguous */:\n                const primaryConfusable = strings.AmbiguousCharacters.getPrimaryConfusable(char.codePointAt(0));\n                return { kind: 0 /* Ambiguous */, confusableWith: String.fromCodePoint(primaryConfusable) };\n            case 1 /* NonBasicASCII */:\n                return { kind: 2 /* NonBasicAscii */ };\n        }\n    }\n}\nfunction buildRegExpCharClassExpr(codePoints, flags) {\n    const src = `[${strings.escapeRegExpCharacters(codePoints.map((i) => String.fromCodePoint(i)).join(''))}]`;\n    return src;\n}\nclass CodePointHighlighter {\n    constructor(options) {\n        this.options = options;\n        this.allowedCodePoints = new Set(options.allowedCodePoints);\n    }\n    getCandidateCodePoints() {\n        if (this.options.nonBasicASCII) {\n            return 'allNonBasicAscii';\n        }\n        const set = new Set();\n        if (this.options.invisibleCharacters) {\n            for (const cp of strings.InvisibleCharacters.codePoints) {\n                set.add(cp);\n            }\n        }\n        if (this.options.ambiguousCharacters) {\n            for (const cp of strings.AmbiguousCharacters.getPrimaryConfusableCodePoints()) {\n                set.add(cp);\n            }\n        }\n        for (const cp of this.allowedCodePoints) {\n            set.delete(cp);\n        }\n        return set;\n    }\n    shouldHighlightNonBasicASCII(character) {\n        const codePoint = character.codePointAt(0);\n        if (this.allowedCodePoints.has(codePoint)) {\n            return 0 /* None */;\n        }\n        if (this.options.nonBasicASCII) {\n            return 1 /* NonBasicASCII */;\n        }\n        if (this.options.invisibleCharacters) {\n            const isAllowedInvisibleCharacter = character === ' ' || character === '\\n' || character === '\\t';\n            // TODO check for emojis\n            if (!isAllowedInvisibleCharacter && strings.InvisibleCharacters.isInvisibleCharacter(codePoint)) {\n                return 2 /* Invisible */;\n            }\n        }\n        if (this.options.ambiguousCharacters) {\n            if (strings.AmbiguousCharacters.isAmbiguous(codePoint)) {\n                return 3 /* Ambiguous */;\n            }\n        }\n        return 0 /* None */;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { stringDiff } from '../../../base/common/diff/diff.js';\nimport { globals } from '../../../base/common/platform.js';\nimport { URI } from '../../../base/common/uri.js';\nimport { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { DiffComputer } from '../diff/diffComputer.js';\nimport { MirrorTextModel as BaseMirrorModel } from '../model/mirrorTextModel.js';\nimport { ensureValidWordDefinition, getWordAtText } from '../model/wordHelper.js';\nimport { computeLinks } from '../modes/linkComputer.js';\nimport { BasicInplaceReplace } from '../modes/supports/inplaceReplaceSupport.js';\nimport { createMonacoBaseAPI } from '../standalone/standaloneBase.js';\nimport * as types from '../../../base/common/types.js';\nimport { StopWatch } from '../../../base/common/stopwatch.js';\nimport { UnicodeTextModelHighlighter } from '../modes/unicodeTextModelHighlighter.js';\n/**\n * @internal\n */\nexport class MirrorModel extends BaseMirrorModel {\n    get uri() {\n        return this._uri;\n    }\n    get eol() {\n        return this._eol;\n    }\n    getValue() {\n        return this.getText();\n    }\n    getLinesContent() {\n        return this._lines.slice(0);\n    }\n    getLineCount() {\n        return this._lines.length;\n    }\n    getLineContent(lineNumber) {\n        return this._lines[lineNumber - 1];\n    }\n    getWordAtPosition(position, wordDefinition) {\n        let wordAtText = getWordAtText(position.column, ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);\n        if (wordAtText) {\n            return new Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);\n        }\n        return null;\n    }\n    words(wordDefinition) {\n        const lines = this._lines;\n        const wordenize = this._wordenize.bind(this);\n        let lineNumber = 0;\n        let lineText = '';\n        let wordRangesIdx = 0;\n        let wordRanges = [];\n        return {\n            *[Symbol.iterator]() {\n                while (true) {\n                    if (wordRangesIdx < wordRanges.length) {\n                        const value = lineText.substring(wordRanges[wordRangesIdx].start, wordRanges[wordRangesIdx].end);\n                        wordRangesIdx += 1;\n                        yield value;\n                    }\n                    else {\n                        if (lineNumber < lines.length) {\n                            lineText = lines[lineNumber];\n                            wordRanges = wordenize(lineText, wordDefinition);\n                            wordRangesIdx = 0;\n                            lineNumber += 1;\n                        }\n                        else {\n                            break;\n                        }\n                    }\n                }\n            }\n        };\n    }\n    getLineWords(lineNumber, wordDefinition) {\n        let content = this._lines[lineNumber - 1];\n        let ranges = this._wordenize(content, wordDefinition);\n        let words = [];\n        for (const range of ranges) {\n            words.push({\n                word: content.substring(range.start, range.end),\n                startColumn: range.start + 1,\n                endColumn: range.end + 1\n            });\n        }\n        return words;\n    }\n    _wordenize(content, wordDefinition) {\n        const result = [];\n        let match;\n        wordDefinition.lastIndex = 0; // reset lastIndex just to be sure\n        while (match = wordDefinition.exec(content)) {\n            if (match[0].length === 0) {\n                // it did match the empty string\n                break;\n            }\n            result.push({ start: match.index, end: match.index + match[0].length });\n        }\n        return result;\n    }\n    getValueInRange(range) {\n        range = this._validateRange(range);\n        if (range.startLineNumber === range.endLineNumber) {\n            return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);\n        }\n        let lineEnding = this._eol;\n        let startLineIndex = range.startLineNumber - 1;\n        let endLineIndex = range.endLineNumber - 1;\n        let resultLines = [];\n        resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));\n        for (let i = startLineIndex + 1; i < endLineIndex; i++) {\n            resultLines.push(this._lines[i]);\n        }\n        resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));\n        return resultLines.join(lineEnding);\n    }\n    offsetAt(position) {\n        position = this._validatePosition(position);\n        this._ensureLineStarts();\n        return this._lineStarts.getPrefixSum(position.lineNumber - 2) + (position.column - 1);\n    }\n    positionAt(offset) {\n        offset = Math.floor(offset);\n        offset = Math.max(0, offset);\n        this._ensureLineStarts();\n        let out = this._lineStarts.getIndexOf(offset);\n        let lineLength = this._lines[out.index].length;\n        // Ensure we return a valid position\n        return {\n            lineNumber: 1 + out.index,\n            column: 1 + Math.min(out.remainder, lineLength)\n        };\n    }\n    _validateRange(range) {\n        const start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });\n        const end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });\n        if (start.lineNumber !== range.startLineNumber\n            || start.column !== range.startColumn\n            || end.lineNumber !== range.endLineNumber\n            || end.column !== range.endColumn) {\n            return {\n                startLineNumber: start.lineNumber,\n                startColumn: start.column,\n                endLineNumber: end.lineNumber,\n                endColumn: end.column\n            };\n        }\n        return range;\n    }\n    _validatePosition(position) {\n        if (!Position.isIPosition(position)) {\n            throw new Error('bad position');\n        }\n        let { lineNumber, column } = position;\n        let hasChanged = false;\n        if (lineNumber < 1) {\n            lineNumber = 1;\n            column = 1;\n            hasChanged = true;\n        }\n        else if (lineNumber > this._lines.length) {\n            lineNumber = this._lines.length;\n            column = this._lines[lineNumber - 1].length + 1;\n            hasChanged = true;\n        }\n        else {\n            let maxCharacter = this._lines[lineNumber - 1].length + 1;\n            if (column < 1) {\n                column = 1;\n                hasChanged = true;\n            }\n            else if (column > maxCharacter) {\n                column = maxCharacter;\n                hasChanged = true;\n            }\n        }\n        if (!hasChanged) {\n            return position;\n        }\n        else {\n            return { lineNumber, column };\n        }\n    }\n}\n/**\n * @internal\n */\nexport class EditorSimpleWorker {\n    constructor(host, foreignModuleFactory) {\n        this._host = host;\n        this._models = Object.create(null);\n        this._foreignModuleFactory = foreignModuleFactory;\n        this._foreignModule = null;\n    }\n    dispose() {\n        this._models = Object.create(null);\n    }\n    _getModel(uri) {\n        return this._models[uri];\n    }\n    _getModels() {\n        let all = [];\n        Object.keys(this._models).forEach((key) => all.push(this._models[key]));\n        return all;\n    }\n    acceptNewModel(data) {\n        this._models[data.url] = new MirrorModel(URI.parse(data.url), data.lines, data.EOL, data.versionId);\n    }\n    acceptModelChanged(strURL, e) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        let model = this._models[strURL];\n        model.onEvents(e);\n    }\n    acceptRemovedModel(strURL) {\n        if (!this._models[strURL]) {\n            return;\n        }\n        delete this._models[strURL];\n    }\n    computeUnicodeHighlights(url, options, range) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const model = this._getModel(url);\n            if (!model) {\n                return { ranges: [], hasMore: false, ambiguousCharacterCount: 0, invisibleCharacterCount: 0, nonBasicAsciiCharacterCount: 0 };\n            }\n            return UnicodeTextModelHighlighter.computeUnicodeHighlights(model, options, range);\n        });\n    }\n    // ---- BEGIN diff --------------------------------------------------------------------------\n    computeDiff(originalUrl, modifiedUrl, ignoreTrimWhitespace, maxComputationTime) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const original = this._getModel(originalUrl);\n            const modified = this._getModel(modifiedUrl);\n            if (!original || !modified) {\n                return null;\n            }\n            const originalLines = original.getLinesContent();\n            const modifiedLines = modified.getLinesContent();\n            const diffComputer = new DiffComputer(originalLines, modifiedLines, {\n                shouldComputeCharChanges: true,\n                shouldPostProcessCharChanges: true,\n                shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,\n                shouldMakePrettyDiff: true,\n                maxComputationTime: maxComputationTime\n            });\n            const diffResult = diffComputer.computeDiff();\n            const identical = (diffResult.changes.length > 0 ? false : this._modelsAreIdentical(original, modified));\n            return {\n                quitEarly: diffResult.quitEarly,\n                identical: identical,\n                changes: diffResult.changes\n            };\n        });\n    }\n    _modelsAreIdentical(original, modified) {\n        const originalLineCount = original.getLineCount();\n        const modifiedLineCount = modified.getLineCount();\n        if (originalLineCount !== modifiedLineCount) {\n            return false;\n        }\n        for (let line = 1; line <= originalLineCount; line++) {\n            const originalLine = original.getLineContent(line);\n            const modifiedLine = modified.getLineContent(line);\n            if (originalLine !== modifiedLine) {\n                return false;\n            }\n        }\n        return true;\n    }\n    computeMoreMinimalEdits(modelUrl, edits) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const model = this._getModel(modelUrl);\n            if (!model) {\n                return edits;\n            }\n            const result = [];\n            let lastEol = undefined;\n            edits = edits.slice(0).sort((a, b) => {\n                if (a.range && b.range) {\n                    return Range.compareRangesUsingStarts(a.range, b.range);\n                }\n                // eol only changes should go to the end\n                let aRng = a.range ? 0 : 1;\n                let bRng = b.range ? 0 : 1;\n                return aRng - bRng;\n            });\n            for (let { range, text, eol } of edits) {\n                if (typeof eol === 'number') {\n                    lastEol = eol;\n                }\n                if (Range.isEmpty(range) && !text) {\n                    // empty change\n                    continue;\n                }\n                const original = model.getValueInRange(range);\n                text = text.replace(/\\r\\n|\\n|\\r/g, model.eol);\n                if (original === text) {\n                    // noop\n                    continue;\n                }\n                // make sure diff won't take too long\n                if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {\n                    result.push({ range, text });\n                    continue;\n                }\n                // compute diff between original and edit.text\n                const changes = stringDiff(original, text, false);\n                const editOffset = model.offsetAt(Range.lift(range).getStartPosition());\n                for (const change of changes) {\n                    const start = model.positionAt(editOffset + change.originalStart);\n                    const end = model.positionAt(editOffset + change.originalStart + change.originalLength);\n                    const newEdit = {\n                        text: text.substr(change.modifiedStart, change.modifiedLength),\n                        range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }\n                    };\n                    if (model.getValueInRange(newEdit.range) !== newEdit.text) {\n                        result.push(newEdit);\n                    }\n                }\n            }\n            if (typeof lastEol === 'number') {\n                result.push({ eol: lastEol, text: '', range: { startLineNumber: 0, startColumn: 0, endLineNumber: 0, endColumn: 0 } });\n            }\n            return result;\n        });\n    }\n    // ---- END minimal edits ---------------------------------------------------------------\n    computeLinks(modelUrl) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return null;\n            }\n            return computeLinks(model);\n        });\n    }\n    textualSuggest(modelUrls, leadingWord, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const sw = new StopWatch(true);\n            const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            const seen = new Set();\n            outer: for (let url of modelUrls) {\n                const model = this._getModel(url);\n                if (!model) {\n                    continue;\n                }\n                for (let word of model.words(wordDefRegExp)) {\n                    if (word === leadingWord || !isNaN(Number(word))) {\n                        continue;\n                    }\n                    seen.add(word);\n                    if (seen.size > EditorSimpleWorker._suggestionsLimit) {\n                        break outer;\n                    }\n                }\n            }\n            return { words: Array.from(seen), duration: sw.elapsed() };\n        });\n    }\n    // ---- END suggest --------------------------------------------------------------------------\n    //#region -- word ranges --\n    computeWordRanges(modelUrl, range, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return Object.create(null);\n            }\n            const wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            const result = Object.create(null);\n            for (let line = range.startLineNumber; line < range.endLineNumber; line++) {\n                let words = model.getLineWords(line, wordDefRegExp);\n                for (const word of words) {\n                    if (!isNaN(Number(word.word))) {\n                        continue;\n                    }\n                    let array = result[word.word];\n                    if (!array) {\n                        array = [];\n                        result[word.word] = array;\n                    }\n                    array.push({\n                        startLineNumber: line,\n                        startColumn: word.startColumn,\n                        endLineNumber: line,\n                        endColumn: word.endColumn\n                    });\n                }\n            }\n            return result;\n        });\n    }\n    //#endregion\n    navigateValueSet(modelUrl, range, up, wordDef, wordDefFlags) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let model = this._getModel(modelUrl);\n            if (!model) {\n                return null;\n            }\n            let wordDefRegExp = new RegExp(wordDef, wordDefFlags);\n            if (range.startColumn === range.endColumn) {\n                range = {\n                    startLineNumber: range.startLineNumber,\n                    startColumn: range.startColumn,\n                    endLineNumber: range.endLineNumber,\n                    endColumn: range.endColumn + 1\n                };\n            }\n            let selectionText = model.getValueInRange(range);\n            let wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);\n            if (!wordRange) {\n                return null;\n            }\n            let word = model.getValueInRange(wordRange);\n            let result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);\n            return result;\n        });\n    }\n    // ---- BEGIN foreign module support --------------------------------------------------------------------------\n    loadForeignModule(moduleId, createData, foreignHostMethods) {\n        const proxyMethodRequest = (method, args) => {\n            return this._host.fhr(method, args);\n        };\n        const foreignHost = types.createProxyObject(foreignHostMethods, proxyMethodRequest);\n        let ctx = {\n            host: foreignHost,\n            getMirrorModels: () => {\n                return this._getModels();\n            }\n        };\n        if (this._foreignModuleFactory) {\n            this._foreignModule = this._foreignModuleFactory(ctx, createData);\n            // static foreing module\n            return Promise.resolve(types.getAllMethodNames(this._foreignModule));\n        }\n        // ESM-comment-begin\n        // \t\treturn new Promise<any>((resolve, reject) => {\n        // \t\t\trequire([moduleId], (foreignModule: { create: IForeignModuleFactory }) => {\n        // \t\t\t\tthis._foreignModule = foreignModule.create(ctx, createData);\n        // \n        // \t\t\t\tresolve(types.getAllMethodNames(this._foreignModule));\n        // \n        // \t\t\t}, reject);\n        // \t\t});\n        // ESM-comment-end\n        // ESM-uncomment-begin\n        return Promise.reject(new Error(`Unexpected usage`));\n        // ESM-uncomment-end\n    }\n    // foreign method request\n    fmr(method, args) {\n        if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {\n            return Promise.reject(new Error('Missing requestHandler or method: ' + method));\n        }\n        try {\n            return Promise.resolve(this._foreignModule[method].apply(this._foreignModule, args));\n        }\n        catch (e) {\n            return Promise.reject(e);\n        }\n    }\n}\n// ---- END diff --------------------------------------------------------------------------\n// ---- BEGIN minimal edits ---------------------------------------------------------------\nEditorSimpleWorker._diffLimit = 100000;\n// ---- BEGIN suggest --------------------------------------------------------------------------\nEditorSimpleWorker._suggestionsLimit = 10000;\n/**\n * Called on the worker side\n * @internal\n */\nexport function create(host) {\n    return new EditorSimpleWorker(host, null);\n}\nif (typeof importScripts === 'function') {\n    // Running in a web worker\n    globals.monaco = createMonacoBaseAPI();\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { splitLines } from '../../../base/common/strings.js';\nimport { Position } from '../core/position.js';\nimport { PrefixSumComputer } from '../viewModel/prefixSumComputer.js';\nexport class MirrorTextModel {\n    constructor(uri, lines, eol, versionId) {\n        this._uri = uri;\n        this._lines = lines;\n        this._eol = eol;\n        this._versionId = versionId;\n        this._lineStarts = null;\n        this._cachedTextValue = null;\n    }\n    dispose() {\n        this._lines.length = 0;\n    }\n    get version() {\n        return this._versionId;\n    }\n    getText() {\n        if (this._cachedTextValue === null) {\n            this._cachedTextValue = this._lines.join(this._eol);\n        }\n        return this._cachedTextValue;\n    }\n    onEvents(e) {\n        if (e.eol && e.eol !== this._eol) {\n            this._eol = e.eol;\n            this._lineStarts = null;\n        }\n        // Update my lines\n        const changes = e.changes;\n        for (const change of changes) {\n            this._acceptDeleteRange(change.range);\n            this._acceptInsertText(new Position(change.range.startLineNumber, change.range.startColumn), change.text);\n        }\n        this._versionId = e.versionId;\n        this._cachedTextValue = null;\n    }\n    _ensureLineStarts() {\n        if (!this._lineStarts) {\n            const eolLength = this._eol.length;\n            const linesLength = this._lines.length;\n            const lineStartValues = new Uint32Array(linesLength);\n            for (let i = 0; i < linesLength; i++) {\n                lineStartValues[i] = this._lines[i].length + eolLength;\n            }\n            this._lineStarts = new PrefixSumComputer(lineStartValues);\n        }\n    }\n    /**\n     * All changes to a line's text go through this method\n     */\n    _setLineText(lineIndex, newValue) {\n        this._lines[lineIndex] = newValue;\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.setValue(lineIndex, this._lines[lineIndex].length + this._eol.length);\n        }\n    }\n    _acceptDeleteRange(range) {\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            // Delete text on the affected line\n            this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n                + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));\n            return;\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)\n            + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));\n        // Delete middle lines\n        this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n        }\n    }\n    _acceptInsertText(position, insertText) {\n        if (insertText.length === 0) {\n            // Nothing to insert\n            return;\n        }\n        let insertLines = splitLines(insertText);\n        if (insertLines.length === 1) {\n            // Inserting text on one line\n            this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n                + insertLines[0]\n                + this._lines[position.lineNumber - 1].substring(position.column - 1));\n            return;\n        }\n        // Append overflowing text from first line to the end of text to insert\n        insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);\n        // Delete overflowing text from first line and insert text on first line\n        this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)\n            + insertLines[0]);\n        // Insert new lines & store lengths\n        let newLengths = new Uint32Array(insertLines.length - 1);\n        for (let i = 1; i < insertLines.length; i++) {\n            this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);\n            newLengths[i - 1] = insertLines[i].length + this._eol.length;\n        }\n        if (this._lineStarts) {\n            // update prefix sum\n            this._lineStarts.insertValues(position.lineNumber, newLengths);\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';\nimport { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';\nlet initialized = false;\nexport function initialize(foreignModule) {\n    if (initialized) {\n        return;\n    }\n    initialized = true;\n    const simpleWorker = new SimpleWorkerServer((msg) => {\n        self.postMessage(msg);\n    }, (host) => new EditorSimpleWorker(host, foreignModule));\n    self.onmessage = (e) => {\n        simpleWorker.onmessage(e.data);\n    };\n}\nself.onmessage = (e) => {\n    // Ignore first message in this case and initialize if not yet initialized\n    if (!initialized) {\n        initialize(null);\n    }\n};\n"],"names":["__webpack_require__","g","globalThis","this","Function","e","window","errorHandler","constructor","listeners","unexpectedErrorHandler","setTimeout","stack","Error","message","emit","forEach","listener","onUnexpectedError","onUnexpectedExternalError","isPromiseCanceledError","transformErrorForSerialization","error","name","$isError","stacktrace","canceledName","NotSupportedError","super","once","fn","_this","result","didCall","apply","arguments","Iterable","is","thing","Symbol","iterator","_empty","Object","freeze","empty","single","element","from","iterable","isEmpty","next","done","first","value","some","predicate","find","filter","map","index","concat","iterables","concatNested","reduce","reducer","initialValue","slice","arr","to","length","consume","atMost","Number","POSITIVE_INFINITY","consumed","i","push","equals","a","b","comparator","at","bt","ai","bi","an","bn","disposableTracker","_a","trackDisposable","x","markAsDisposed","disposable","setParentOfDisposable","child","parent","setParent","MultiDisposeError","errors","join","dispose","arg","d","Array","isArray","combinedDisposable","disposables","toDisposable","children","setParentOfDisposables","self","DisposableStore","_toDispose","Set","_isDisposed","clear","values","add","o","DISABLE_DISPOSED_WARNING","_store","_register","None","Node","Undefined","prev","undefined","_first","_last","_size","size","node","unshift","_insert","atTheEnd","newNode","oldLast","oldFirst","didRemove","_remove","shift","res","pop","anchor","LANGUAGE_DEFAULT","_locale","_userAgent","_isWindows","_isMacintosh","_isLinux","_isLinuxSnap","_isNative","_isWeb","_isElectron","_isIOS","_language","_translationsConfigFile","nodeProcess","vscode","process","isElectronProcess","versions","electron","isElectronRenderer","type","navigator","platform","env","rawNlsConfig","nlsConfig","JSON","parse","resolved","availableLanguages","locale","userAgent","indexOf","maxTouchPoints","language","_platform","isWindows","isMacintosh","setTimeout0","postMessage","importScripts","pending","addEventListener","data","vscodeScheduleAsyncWork","len","candidate","id","splice","callback","lastId","myId","setImmediate","bind","nextTick","_promise","Promise","resolve","hasPerformanceNow","StopWatch","highResolution","_highResolution","_startTime","_now","_stopTime","static","stop","elapsed","Date","now","Event","event","thisArgs","didFire","call","snapshot","each","merge","initial","output","emitter","Emitter","onFirstListenerAdd","fire","onLastListenerRemove","debounce","delay","leading","leakWarningThreshold","subscription","handle","numDebouncedCalls","cur","clearTimeout","_output","latch","cache","firstCall","shouldEmit","signal","any","events","split","isT","buffer","flushAfterTimeout","_buffer","flush","onFirstListenerDidAdd","ChainableEvent","on","chain","fromNodeEventEmitter","eventName","args","removeListener","fromDOMEventEmitter","removeEventListener","toPromise","EventProfiling","_listenerCount","_invocationCount","_elapsedOverall","_name","_idPool","start","listenerCount","_stopWatch","options","_disposed","_options","_leakageMon","_perfMon","_profName","_event","_listeners","firstListener","remove","onListenerDidAdd","removeMonitor","check","_b","_deliveryQueue","_c","_d","_e","getAllMethodNames","obj","methods","prop","proto","getPrototypeOf","prototype","getOwnPropertyNames","getAllPropertyNames","assertNever","escapeRegExpCharacters","replace","isUpperAsciiLetter","code","isHighSurrogate","charCode","isLowSurrogate","computeCodePoint","highSurrogate","lowSurrogate","getNextCodePoint","str","offset","charCodeAt","nextCharCode","String","fromCharCode","GraphemeBreakTree","_data","_INSTANCE","getGraphemeBreakType","codePoint","nodeCount","nodeIndex","AmbiguousCharacters","getData","arrayToMap","Map","set","additionalConfusables","originalCodePoint","getConfusablesForCurrentLocale","has","get","keys","InvisibleCharacters","getRawData","codePoints","INITIALIZE","safeProcess","RequestMessage","vsWorker","req","method","ReplyMessage","seq","err","SubscribeEventMessage","EventMessage","UnsubscribeEventMessage","SimpleWorkerProtocol","handler","_workerId","_handler","_lastSentReq","_pendingReplies","create","_pendingEmitters","_pendingEvents","setWorkerId","workerId","sendMessage","reject","_send","listen","delete","handleMessage","_handleMessage","msg","_handleReplyMessage","_handleRequestMessage","_handleSubscribeEventMessage","_handleEventMessage","_handleUnsubscribeEventMessage","replyMessage","reply","requestMessage","then","r","detail","handleEvent","transfer","ArrayBuffer","propertyIsEvent","propertyIsDynamicEvent","test","methodNames","invoke","proxyListen","createProxyMethod","createProxyDynamicEvent","methodName","SimpleWorkerServer","requestHandlerFactory","_requestHandlerFactory","_requestHandler","_protocol","_handleEvent","onmessage","initialize","loaderConfig","moduleId","hostMethods","hostProxy","baseUrl","paths","vs","trustedTypesPolicy","catchError","module","DiffChange","originalStart","originalLength","modifiedStart","modifiedLength","getOriginalEnd","getModifiedEnd","numberHash","val","initialHashVal","stringHash","s","hashVal","leftRotate","bits","totalBits","delta","fill","dest","count","byteLength","toHexString","bufferOrValue","bitsize","Uint8Array","toString","padStart","char","leftPad","StringSHA1","_h0","_h1","_h2","_h3","_h4","_buff","_buffDV","DataView","_buffLen","_totalLen","_leftoverHighSurrogate","_finished","update","strLen","buff","buffLen","leftoverHighSurrogate","_push","_step","digest","_wrapUp","ml","setUint32","Math","floor","bigBlock32","_bigBlock32","j","getUint32","f","k","temp","c","StringDiffSequence","source","getElements","characters","Int32Array","stringDiff","original","modified","pretty","LcsDiff","ComputeDiff","changes","Debug","condition","MyArray","sourceArray","sourceIndex","destinationArray","destinationIndex","DiffChangeHelper","m_changes","m_originalStart","m_modifiedStart","m_originalCount","m_modifiedCount","MarkNextChange","AddOriginalElement","originalIndex","modifiedIndex","min","AddModifiedElement","getChanges","getReverseChanges","reverse","originalSequence","modifiedSequence","continueProcessingPredicate","ContinueProcessingPredicate","_originalSequence","_modifiedSequence","originalStringElements","originalElementsOrHash","originalHasStrings","_getElements","modifiedStringElements","modifiedElementsOrHash","modifiedHasStrings","_hasStrings","_originalStringElements","_originalElementsOrHash","_modifiedStringElements","_modifiedElementsOrHash","m_forwardHistory","m_reverseHistory","sequence","elements","_isStringArray","hashes","ElementsAreEqual","newIndex","ElementsAreStrictEqual","_getStrictElement","getStrictElement","OriginalElementsAreEqual","index1","index2","ModifiedElementsAreEqual","_ComputeDiff","originalEnd","modifiedEnd","quitEarlyArr","ComputeDiffRecursive","PrettifyChanges","quitEarly","Assert","midOriginalArr","midModifiedArr","ComputeRecursionPoint","midOriginal","midModified","leftChanges","rightChanges","ConcatenateChanges","WALKTRACE","diagonalForwardBase","diagonalForwardStart","diagonalForwardEnd","diagonalForwardOffset","diagonalReverseBase","diagonalReverseStart","diagonalReverseEnd","diagonalReverseOffset","forwardPoints","reversePoints","deltaIsEven","forwardChanges","reverseChanges","changeHelper","diagonalMin","diagonalMax","diagonalRelative","lastOriginalIndex","historyIndex","diagonal","originalStartPoint","modifiedStartPoint","lastForwardChange","max","maxDifferences","numDiagonals","numDifferences","furthestOriginalIndex","furthestModifiedIndex","ClipDiagonalBound","tempOriginalIndex","abs","matchLengthOfLongest","Copy2","change","originalStop","modifiedStop","checkOriginal","checkModified","startStrictEqual","mergedChangeArr","ChangesOverlap","prevChange","bestDelta","bestScore","_boundaryScore","score","aChange","bChange","matchedLength","aOriginalStart","bOriginalEnd","abOriginalLength","aModifiedStart","bModifiedEnd","abModifiedLength","t","_findBetterContiguousSequence","originalMatchStart","modifiedMatchStart","desiredLength","originalMax","modifiedMax","bestOriginalStart","bestModifiedStart","_contiguousSequenceScore","l","_OriginalIsBoundary","_OriginalRegionIsBoundary","_ModifiedIsBoundary","_ModifiedRegionIsBoundary","left","right","Copy","diagonalBaseIndex","diffEven","sandboxProcess","arch","cwd","CHAR_DOT","CHAR_FORWARD_SLASH","CHAR_BACKWARD_SLASH","CHAR_COLON","ErrorInvalidArgType","expected","actual","determiner","validateString","isPathSeparator","isPosixPathSeparator","isWindowsDeviceRoot","normalizeString","path","allowAboveRoot","separator","lastSegmentLength","lastSlash","dots","lastSlashIndex","lastIndexOf","_format","sep","pathObject","dir","root","base","ext","win32","pathSegments","resolvedDevice","resolvedTail","resolvedAbsolute","toLowerCase","rootEnd","device","isAbsolute","last","firstPart","normalize","tail","joined","needsReplace","slashCount","firstLen","relative","fromOrig","toOrig","fromStart","fromEnd","fromLen","toStart","toEnd","toLen","lastCommonSep","fromCode","out","toNamespacedPath","resolvedPath","dirname","end","matchedSlash","basename","extIdx","firstNonSlashEnd","extname","startDot","startPart","preDotState","format","ret","delimiter","posix","trailingSeparator","hasRoot","_schemePattern","_singleSlashStart","_doubleSlashStart","_validateUri","_strict","scheme","authority","query","fragment","_slash","_regexp","URI","schemeOrData","_schemeFix","_referenceResolution","fsPath","with","uriToFsPath","Uri","match","exec","percentDecode","idx","substring","components","uri","pathFragment","newPath","file","skipEncoding","_asFormatted","toJSON","_formatted","external","_fsPath","_sep","_pathSepMarker","$mid","encodeTable","encodeURIComponentFast","uriComponent","allowSlash","nativeEncodePos","pos","encodeURIComponent","charAt","substr","escaped","encodeURIComponentMinimal","keepDriveLetterCasing","encoder","userinfo","decodeURIComponentGraceful","decodeURIComponent","_rEncodedAsHex","lineNumber","column","newLineNumber","newColumn","deltaLineNumber","deltaColumn","other","isBefore","isBeforeOrEqual","aLineNumber","bLineNumber","clone","startLineNumber","startColumn","endLineNumber","endColumn","range","containsPosition","position","containsRange","otherRange","strictContainsRange","plusRange","intersectRanges","resultStartLineNumber","resultStartColumn","resultEndLineNumber","resultEndColumn","otherStartLineNumber","otherStartColumn","otherEndLineNumber","otherEndColumn","equalsRange","getEndPosition","getStartPosition","setEndPosition","setStartPosition","collapseToStart","aStartLineNumber","bStartLineNumber","aStartColumn","bStartColumn","aEndLineNumber","bEndLineNumber","computeDiff","LineSequence","lines","startColumns","endColumns","getFirstNonBlankColumn","getLastNonBlankColumn","_startColumns","_endColumns","getStartLineNumber","getEndLineNumber","createCharSequence","shouldIgnoreTrimWhitespace","startIndex","endIndex","charCodes","lineNumbers","columns","lineContent","col","CharSequence","_charCodes","_lineNumbers","_columns","getStartColumn","getEndColumn","CharChange","originalStartLineNumber","originalStartColumn","originalEndLineNumber","originalEndColumn","modifiedStartLineNumber","modifiedStartColumn","modifiedEndLineNumber","modifiedEndColumn","diffChange","originalCharSequence","modifiedCharSequence","LineChange","charChanges","originalLineSequence","modifiedLineSequence","continueCharDiff","shouldComputeCharChanges","shouldPostProcessCharChanges","rawChanges","currChange","originalMatchingLength","modifiedMatchingLength","postProcessCharChanges","createFromDiffChange","DiffComputer","originalLines","modifiedLines","opts","shouldMakePrettyDiff","continueLineDiff","createContinueProcessingPredicate","maxComputationTime","diffResult","lineChanges","createFromDiffResult","originalLineIndex","modifiedLineIndex","nextChange","originalLine","modifiedLine","_pushTrimWhitespaceCharChange","originalMaxColumn","modifiedMaxColumn","originalLineNumber","modifiedLineNumber","_mergeTrimWhitespaceCharChange","txt","defaultValue","chCode","maximumRuntime","startTime","toUint8","v","toUint32","PrefixSumComputer","prefixSum","Uint32Array","prefixSumValidIndex","insertValues","insertIndex","oldValues","oldPrefixSum","insertValuesLen","subarray","setValue","removeValues","maxCount","getTotalSum","_getPrefixSum","getPrefixSum","getIndexOf","sum","low","high","mid","midStop","midStart","PrefixSumIndexOfResult","remainder","_prefixSumIndexOfResultBrand","DEFAULT_WORD_REGEXP","allowInWords","RegExp","createWordRegExp","_defaultConfig","maxLen","windowSize","timeBudget","getWordAtText","wordDefinition","text","textOffset","config","t1","prevRegexIndex","regexIndex","lastIndex","thisMatch","_findRegexMatchEnclosingPosition","word","stopPos","matchIndex","CharacterClassifier","_defaultValue","_asciiMap","_createAsciiMap","_map","asciiMap","_value","Uint8Matrix","rows","cols","row","StateMachine","edges","maxCharCode","maxState","states","_states","_maxCharCode","nextState","currentState","_stateMachine","_classifier","LinkComputer","classifier","line","linkBeginIndex","linkEndIndex","lastIncludedCharIndex","charCodeBeforeLink","lastCharCodeInLink","url","model","stateMachine","getStateMachine","FORCE_TERMINATION_CHARACTERS","CANNOT_END_WITH_CHARACTERS","getClassifier","lineCount","getLineCount","getLineContent","linkBeginChCode","state","hasOpenParens","hasOpenSquareBracket","inSquareBrackets","hasOpenCurlyBracket","resetStateMachine","chClass","_createLink","BasicInplaceReplace","_defaultValueSet","navigateValueSet","range1","text1","range2","text2","up","doNavigateValueSet","numberResult","numberReplace","textReplace","precision","pow","n1","n2","parseFloat","isNaN","valueSetsReplace","valueSets","valueSetReplace","valueSet","INSTANCE","shortcutEvent","context","CancellationToken","isCancellationToken","Cancelled","MutableToken","isCancellationRequested","onCancellationRequested","_isCancelled","_emitter","cancel","CancellationTokenSource","_token","_parentListener","token","KeyCodeStrMap","_keyCodeToStr","_strToKeyCode","define","keyCode","keyCodeToStr","strToKeyCode","uiMap","userSettingsUSMap","userSettingsGeneralMap","EVENT_KEY_CODE_MAP","NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE","scanCodeIntToStr","scanCodeStrToInt","scanCodeLowerCaseStrToInt","IMMUTABLE_CODE_TO_KEY_CODE","IMMUTABLE_KEY_CODE_TO_CODE","KeyCodeUtils","AccessibilitySupport","CompletionItemInsertTextRule","CompletionItemKind","CompletionItemTag","CompletionTriggerKind","ContentWidgetPositionPreference","CursorChangeReason","DefaultEndOfLine","DocumentHighlightKind","EditorAutoIndentStrategy","EditorOption","EndOfLinePreference","EndOfLineSequence","IndentAction","InlayHintKind","InlineCompletionTriggerKind","KeyCode","MarkerSeverity","MarkerTag","MinimapPosition","MouseTargetType","OverlayWidgetPositionPreference","OverviewRulerLane","RenderLineNumbersType","RenderMinimap","ScrollType","ScrollbarVisibility","SelectionDirection","SignatureHelpTriggerKind","SymbolKind","SymbolTag","TextEditorCursorBlinkingStyle","TextEditorCursorStyle","TrackedRangeStickiness","WrappingIndent","mappings","seenKeyCode","seenScanCode","mapping","_keyCodeOrd","immutable","scanCode","scanCodeStr","keyCodeStr","eventKeyCode","vkey","usUserSettingsLabel","generalUserSettingsLabel","fromString","key","toUserSettingsUS","toUserSettingsGeneral","fromUserSettings","toElectronAccelerator","Selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","equalsSelection","selectionsEqual","getDirection","getPosition","getSelectionStart","direction","sel","Token","_tokenBrand","KeyMod","secondPart","KeyChord","CtrlCmd","Shift","Alt","WinCtrl","WordCharacterClassifier","wordSeparators","computeFn","input","hasOwnProperty","HorizontalGuidesState","isValidMatch","textLength","matchStartIndex","matchLength","charBefore","firstCharInMatch","leftIsWordBounday","charAfter","lastCharInMatch","rightIsWordBounday","Searcher","searchRegex","_wordSeparators","_searchRegex","_prevMatchStartIndex","_prevMatchLength","reset","m","CodePointHighlighter","allowedCodePoints","getCandidateCodePoints","nonBasicASCII","invisibleCharacters","cp","ambiguousCharacters","shouldHighlightNonBasicASCII","character","codePointAt","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","MirrorModel","eol","versionId","_uri","_lines","_eol","_versionId","_lineStarts","_cachedTextValue","version","getText","onEvents","_acceptDeleteRange","_acceptInsertText","_ensureLineStarts","eolLength","linesLength","lineStartValues","_setLineText","lineIndex","newValue","insertText","insertLines","newLengths","getValue","getLinesContent","getWordAtPosition","wordAtText","global","flags","ignoreCase","multiline","unicode","ensureValidWordDefinition","words","wordenize","_wordenize","lineText","wordRangesIdx","wordRanges","getLineWords","content","ranges","getValueInRange","_validateRange","lineEnding","startLineIndex","endLineIndex","resultLines","offsetAt","_validatePosition","positionAt","lineLength","hasChanged","maxCharacter","EditorSimpleWorker","host","foreignModuleFactory","_host","_models","_foreignModuleFactory","_foreignModule","_getModel","_getModels","all","acceptNewModel","EOL","acceptModelChanged","strURL","acceptRemovedModel","computeUnicodeHighlights","startLine","endLine","codePointHighlighter","candidates","regex","fromCodePoint","searcher","hasMore","ambiguousCharacterCount","invisibleCharacterCount","nonBasicAsciiCharacterCount","forLoop","highlightReason","MAX_RESULT_LENGTH","kind","primaryConfusable","confusableWith","originalUrl","modifiedUrl","ignoreTrimWhitespace","identical","_modelsAreIdentical","originalLineCount","computeMoreMinimalEdits","modelUrl","edits","lastEol","sort","_diffLimit","editOffset","newEdit","computeLinks","textualSuggest","modelUrls","leadingWord","wordDef","wordDefFlags","sw","wordDefRegExp","seen","outer","_suggestionsLimit","duration","computeWordRanges","array","selectionText","wordRange","loadForeignModule","createData","foreignHostMethods","foreignHost","fhr","ctx","getMirrorModels","fmr","editor","languages","Position","Range","initialized","foreignModule","simpleWorker"],"sourceRoot":""}