@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

package/dist/vscode/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -28,6 +28,12 @@ var TunnelType;
     TunnelType["Forwarded"] = "Forwarded";
     TunnelType["Add"] = "Add";
 })(TunnelType || (TunnelType = {}))));
+var TunnelCloseReason;
+( ((function(TunnelCloseReason) {
+    TunnelCloseReason["Other"] = "Other";
+    TunnelCloseReason["User"] = "User";
+    TunnelCloseReason["AutoForwardEnd"] = "AutoForwardEnd";
+})(TunnelCloseReason || (TunnelCloseReason = {}))));
 var TunnelEditId;
 ( ((function(TunnelEditId) {
     TunnelEditId[TunnelEditId["None"] = 0] = "None";
@@ -324,6 +330,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.onEnvironmentTunnelsSet = this._onEnvironmentTunnelsSet.event;
         this._environmentTunnelsSet = false;
         this.unrestoredExtensionTunnels = ( (new Map()));
+        this.sessionCachedProperties = ( (new Map()));
         this.portAttributesProviders = [];
         this.mismatchCooldown = ( (new Date()));
         this.configPortsAttributes = ( (new PortsAttributes(configurationService)));
@@ -385,10 +392,10 @@ let TunnelModel = class TunnelModel extends Disposable {
             this._onForwardPort.fire(this.forwarded.get(key));
         }));
         this._register(this.tunnelService.onTunnelClosed(address => {
-            return this.onTunnelClosed(address);
+            return this.onTunnelClosed(address, TunnelCloseReason.Other);
         }));
     }
-    async onTunnelClosed(address) {
+    async onTunnelClosed(address, reason) {
         const key = makeAddress(address.host, address.port);
         if (( (this.forwarded.has(key)))) {
             this.forwarded.delete(key);
@@ -509,7 +516,8 @@ let TunnelModel = class TunnelModel extends Disposable {
             } : undefined;
             const key = makeAddress(tunnelProperties.remote.host, tunnelProperties.remote.port);
             this.inProgress.set(key, true);
-            let tunnel = await this.tunnelService.openTunnel(addressProvider, tunnelProperties.remote.host, tunnelProperties.remote.port, undefined, localPort, (!tunnelProperties.elevateIfNeeded) ? attributes?.elevateIfNeeded : tunnelProperties.elevateIfNeeded, tunnelProperties.privacy, attributes?.protocol);
+            tunnelProperties = this.mergeCachedAndUnrestoredProperties(key, tunnelProperties);
+            const tunnel = await this.tunnelService.openTunnel(addressProvider, tunnelProperties.remote.host, tunnelProperties.remote.port, undefined, localPort, (!tunnelProperties.elevateIfNeeded) ? attributes?.elevateIfNeeded : tunnelProperties.elevateIfNeeded, tunnelProperties.privacy, attributes?.protocol);
             if (tunnel && tunnel.localAddress) {
                 const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnelProperties.remote.host, tunnelProperties.remote.port);
                 const protocol = (tunnel.protocol ?
@@ -536,37 +544,59 @@ let TunnelModel = class TunnelModel extends Disposable {
                 await this.storeForwarded();
                 await this.showPortMismatchModalIfNeeded(tunnel, localPort, attributes);
                 this._onForwardPort.fire(newForward);
-                if (( (this.unrestoredExtensionTunnels.has(key)))) {
-                    const updateProps = this.unrestoredExtensionTunnels.get(key);
-                    this.unrestoredExtensionTunnels.delete(key);
-                    if (updateProps) {
-                        tunnel = await this.forward({
-                            remote: { host: newForward.remoteHost, port: newForward.remotePort },
-                            local: newForward.localPort,
-                            name: newForward.name,
-                            privacy: updateProps.privacy,
-                            elevateIfNeeded: true,
-                        });
-                    }
-                }
                 return tunnel;
             }
             this.inProgress.delete(key);
         }
         else {
-            const newName = attributes?.label ?? tunnelProperties.name;
-            if (newName !== existingTunnel.name) {
-                existingTunnel.name = newName;
+            return this.mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes);
+        }
+        return undefined;
+    }
+    mergeCachedAndUnrestoredProperties(key, tunnelProperties) {
+        const map = ( (this.unrestoredExtensionTunnels.has(key))) ? this.unrestoredExtensionTunnels : (( (this.sessionCachedProperties.has(key))) ? this.sessionCachedProperties : undefined);
+        if (map) {
+            const updateProps = map.get(key);
+            map.delete(key);
+            if (updateProps) {
+                tunnelProperties.name = updateProps.name ?? tunnelProperties.name;
+                tunnelProperties.local = (('local' in updateProps) ? updateProps.local : (('localPort' in updateProps) ? updateProps.localPort : undefined)) ?? tunnelProperties.local;
+                tunnelProperties.privacy = updateProps.privacy ?? tunnelProperties.privacy;
+            }
+        }
+        return tunnelProperties;
+    }
+    async mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes) {
+        const newName = attributes?.label ?? tunnelProperties.name;
+        let MergedAttributeAction;
+        ( ((function(MergedAttributeAction) {
+            MergedAttributeAction[MergedAttributeAction["None"] = 0] = "None";
+            MergedAttributeAction[MergedAttributeAction["Fire"] = 1] = "Fire";
+            MergedAttributeAction[MergedAttributeAction["Reopen"] = 2] = "Reopen";
+        })(MergedAttributeAction || (MergedAttributeAction = {}))));
+        let mergedAction = MergedAttributeAction.None;
+        if (newName !== existingTunnel.name) {
+            existingTunnel.name = newName;
+            mergedAction = MergedAttributeAction.Fire;
+        }
+        if ((attributes?.protocol || (existingTunnel.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== existingTunnel.protocol)) {
+            tunnelProperties.source = existingTunnel.source;
+            mergedAction = MergedAttributeAction.Reopen;
+        }
+        if (tunnelProperties.privacy && (existingTunnel.privacy !== tunnelProperties.privacy)) {
+            mergedAction = MergedAttributeAction.Reopen;
+        }
+        switch (mergedAction) {
+            case MergedAttributeAction.Fire: {
                 this._onForwardPort.fire();
+                break;
             }
-            if ((attributes?.protocol || (existingTunnel.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== existingTunnel.protocol)) {
-                await this.close(existingTunnel.remoteHost, existingTunnel.remotePort);
-                tunnelProperties.source = existingTunnel.source;
+            case MergedAttributeAction.Reopen: {
+                await this.close(existingTunnel.remoteHost, existingTunnel.remotePort, TunnelCloseReason.User);
                 await this.forward(tunnelProperties, attributes);
             }
-            return mapHasAddressLocalhostOrAllInterfaces(this.remoteTunnels, tunnelProperties.remote.host, tunnelProperties.remote.port);
         }
-        return undefined;
+        return mapHasAddressLocalhostOrAllInterfaces(this.remoteTunnels, tunnelProperties.remote.host, tunnelProperties.remote.port);
     }
     async name(host, port, name) {
         const existingForwarded = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, host, port);
@@ -582,9 +612,18 @@ let TunnelModel = class TunnelModel extends Disposable {
             this._onPortName.fire({ host, port });
         }
     }
-    async close(host, port) {
+    async close(host, port, reason) {
+        const key = makeAddress(host, port);
+        const oldTunnel = this.forwarded.get(key);
+        if (reason === TunnelCloseReason.AutoForwardEnd) {
+            this.sessionCachedProperties.set(key, {
+                local: oldTunnel.localPort,
+                name: oldTunnel.name,
+                privacy: oldTunnel.privacy,
+            });
+        }
         await this.tunnelService.closeTunnel(host, port);
-        return this.onTunnelClosed({ host, port });
+        return this.onTunnelClosed({ host, port }, reason);
     }
     address(host, port) {
         const key = makeAddress(host, port);
@@ -779,4 +818,4 @@ TunnelModel = ( (__decorate([
     ( (__param(6, ILogService))),
     ( (__param(7, IDialogService)))
 ], TunnelModel)));
-export { AutoTunnelSource, IRemoteExplorerService, OnPortForward, PortsAttributes, TUNNEL_VIEW_ID, TunnelEditId, TunnelModel, TunnelSource, TunnelType, UserTunnelSource, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };
+export { AutoTunnelSource, IRemoteExplorerService, OnPortForward, PortsAttributes, TUNNEL_VIEW_ID, TunnelCloseReason, TunnelEditId, TunnelModel, TunnelSource, TunnelType, UserTunnelSource, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };

package/dist/vscode/vs/workbench/services/search/common/fileSearchManager.js

@@ -0,0 +1,265 @@
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { resolvePatternsForProvider, QueryGlobTester, hasSiblingFn } from './search.js';
+class FileSearchEngine {
+    constructor(config, provider, sessionToken) {
+        this.config = config;
+        this.provider = provider;
+        this.sessionToken = sessionToken;
+        this.isLimitHit = false;
+        this.resultCount = 0;
+        this.isCanceled = false;
+        this.filePattern = config.filePattern;
+        this.includePattern = config.includePattern && glob.parse(config.includePattern);
+        this.maxResults = config.maxResults || undefined;
+        this.exists = config.exists;
+        this.activeCancellationTokens = ( new Set());
+        this.globalExcludePattern = config.excludePattern && glob.parse(config.excludePattern);
+    }
+    cancel() {
+        this.isCanceled = true;
+        this.activeCancellationTokens.forEach(t => t.cancel());
+        this.activeCancellationTokens = ( new Set());
+    }
+    search(_onResult) {
+        const folderQueries = this.config.folderQueries || [];
+        return ( new Promise((resolve, reject) => {
+            const onResult = (match) => {
+                this.resultCount++;
+                _onResult(match);
+            };
+            if (this.isCanceled) {
+                return resolve({ limitHit: this.isLimitHit });
+            }
+            if (this.config.extraFileResources) {
+                this.config.extraFileResources
+                    .forEach(extraFile => {
+                    const extraFileStr = ( extraFile.toString());
+                    const basename = path.basename(extraFileStr);
+                    if (this.globalExcludePattern && this.globalExcludePattern(extraFileStr, basename)) {
+                        return;
+                    }
+                    this.matchFile(onResult, { base: extraFile, basename });
+                });
+            }
+            Promise.all(( folderQueries.map(fq => {
+                return this.searchInFolder(fq, onResult);
+            }))).then(stats => {
+                resolve({
+                    limitHit: this.isLimitHit,
+                    stats: stats[0] || undefined
+                });
+            }, (err) => {
+                reject(( new Error(toErrorMessage(err))));
+            });
+        }));
+    }
+    async searchInFolder(fq, onResult) {
+        const cancellation = ( new CancellationTokenSource());
+        const options = this.getSearchOptionsForFolder(fq);
+        const tree = this.initDirectoryTree();
+        const queryTester = ( new QueryGlobTester(this.config, fq));
+        const noSiblingsClauses = !queryTester.hasSiblingExcludeClauses();
+        let providerSW;
+        try {
+            this.activeCancellationTokens.add(cancellation);
+            providerSW = StopWatch.create();
+            const results = await this.provider.provideFileSearchResults({
+                pattern: this.config.filePattern || ''
+            }, options, cancellation.token);
+            const providerTime = providerSW.elapsed();
+            const postProcessSW = StopWatch.create();
+            if (this.isCanceled && !this.isLimitHit) {
+                return null;
+            }
+            if (results) {
+                results.forEach(result => {
+                    const relativePath = path.posix.relative(fq.folder.path, result.path);
+                    if (noSiblingsClauses) {
+                        const basename = path.basename(result.path);
+                        this.matchFile(onResult, { base: fq.folder, relativePath, basename });
+                        return;
+                    }
+                    this.addDirectoryEntries(tree, fq.folder, relativePath, onResult);
+                });
+            }
+            if (this.isCanceled && !this.isLimitHit) {
+                return null;
+            }
+            this.matchDirectoryTree(tree, queryTester, onResult);
+            return {
+                providerTime,
+                postProcessTime: postProcessSW.elapsed()
+            };
+        }
+        finally {
+            cancellation.dispose();
+            this.activeCancellationTokens.delete(cancellation);
+        }
+    }
+    getSearchOptionsForFolder(fq) {
+        const includes = resolvePatternsForProvider(this.config.includePattern, fq.includePattern);
+        const excludes = resolvePatternsForProvider(this.config.excludePattern, fq.excludePattern);
+        return {
+            folder: fq.folder,
+            excludes,
+            includes,
+            useIgnoreFiles: !fq.disregardIgnoreFiles,
+            useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+            useParentIgnoreFiles: !fq.disregardParentIgnoreFiles,
+            followSymlinks: !fq.ignoreSymlinks,
+            maxResults: this.config.maxResults,
+            session: this.sessionToken
+        };
+    }
+    initDirectoryTree() {
+        const tree = {
+            rootEntries: [],
+            pathToEntries: Object.create(null)
+        };
+        tree.pathToEntries['.'] = tree.rootEntries;
+        return tree;
+    }
+    addDirectoryEntries({ pathToEntries }, base, relativeFile, onResult) {
+        if (relativeFile === this.filePattern) {
+            const basename = path.basename(this.filePattern);
+            this.matchFile(onResult, { base: base, relativePath: this.filePattern, basename });
+        }
+        function add(relativePath) {
+            const basename = path.basename(relativePath);
+            const dirname = path.dirname(relativePath);
+            let entries = pathToEntries[dirname];
+            if (!entries) {
+                entries = pathToEntries[dirname] = [];
+                add(dirname);
+            }
+            entries.push({
+                base,
+                relativePath,
+                basename
+            });
+        }
+        add(relativeFile);
+    }
+    matchDirectoryTree({ rootEntries, pathToEntries }, queryTester, onResult) {
+        const self = this;
+        const filePattern = this.filePattern;
+        function matchDirectory(entries) {
+            const hasSibling = hasSiblingFn(() => ( entries.map(entry => entry.basename)));
+            for (let i = 0, n = entries.length; i < n; i++) {
+                const entry = entries[i];
+                const { relativePath, basename } = entry;
+                if (queryTester.matchesExcludesSync(relativePath, basename, filePattern !== basename ? hasSibling : undefined)) {
+                    continue;
+                }
+                const sub = pathToEntries[relativePath];
+                if (sub) {
+                    matchDirectory(sub);
+                }
+                else {
+                    if (relativePath === filePattern) {
+                        continue;
+                    }
+                    self.matchFile(onResult, entry);
+                }
+                if (self.isLimitHit) {
+                    break;
+                }
+            }
+        }
+        matchDirectory(rootEntries);
+    }
+    matchFile(onResult, candidate) {
+        if (!this.includePattern || (candidate.relativePath && this.includePattern(candidate.relativePath, candidate.basename))) {
+            if (this.exists || (this.maxResults && this.resultCount >= this.maxResults)) {
+                this.isLimitHit = true;
+                this.cancel();
+            }
+            if (!this.isLimitHit) {
+                onResult(candidate);
+            }
+        }
+    }
+}
+class FileSearchManager {
+    constructor() {
+        this.sessions = ( new Map());
+    }
+    fileSearch(config, provider, onBatch, token) {
+        const sessionTokenSource = this.getSessionTokenSource(config.cacheKey);
+        const engine = ( new FileSearchEngine(config, provider, sessionTokenSource && sessionTokenSource.token));
+        let resultCount = 0;
+        const onInternalResult = (batch) => {
+            resultCount += batch.length;
+            onBatch(( batch.map(m => this.rawMatchToSearchItem(m))));
+        };
+        return this.doSearch(engine, FileSearchManager.BATCH_SIZE, onInternalResult, token).then(result => {
+            return {
+                limitHit: result.limitHit,
+                stats: {
+                    fromCache: false,
+                    type: 'fileSearchProvider',
+                    resultCount,
+                    detailStats: result.stats
+                }
+            };
+        });
+    }
+    clearCache(cacheKey) {
+        const sessionTokenSource = this.getSessionTokenSource(cacheKey);
+        sessionTokenSource?.cancel();
+    }
+    getSessionTokenSource(cacheKey) {
+        if (!cacheKey) {
+            return undefined;
+        }
+        if (!( this.sessions.has(cacheKey))) {
+            this.sessions.set(cacheKey, ( new CancellationTokenSource()));
+        }
+        return this.sessions.get(cacheKey);
+    }
+    rawMatchToSearchItem(match) {
+        if (match.relativePath) {
+            return {
+                resource: resources.joinPath(match.base, match.relativePath)
+            };
+        }
+        else {
+            return {
+                resource: match.base
+            };
+        }
+    }
+    doSearch(engine, batchSize, onResultBatch, token) {
+        token.onCancellationRequested(() => {
+            engine.cancel();
+        });
+        const _onResult = (match) => {
+            if (match) {
+                batch.push(match);
+                if (batchSize > 0 && batch.length >= batchSize) {
+                    onResultBatch(batch);
+                    batch = [];
+                }
+            }
+        };
+        let batch = [];
+        return engine.search(_onResult).then(result => {
+            if (batch.length) {
+                onResultBatch(batch);
+            }
+            return result;
+        }, error => {
+            if (batch.length) {
+                onResultBatch(batch);
+            }
+            return Promise.reject(error);
+        });
+    }
+}
+FileSearchManager.BATCH_SIZE = 512;
+export { FileSearchManager };

package/dist/vscode/vs/workbench/services/search/common/queryBuilder.js

@@ -67,6 +67,12 @@ let QueryBuilder = class QueryBuilder {
             }
             newPattern.notebookInfo.isInNotebookMarkdownInput = options.notebookSearchConfig.includeMarkupInput;
         }
+        if (options.notebookSearchConfig?.includeMarkupPreview) {
+            if (!newPattern.notebookInfo) {
+                newPattern.notebookInfo = {};
+            }
+            newPattern.notebookInfo.isInNotebookMarkdownPreview = options.notebookSearchConfig.includeMarkupPreview;
+        }
         if (options.notebookSearchConfig?.includeCodeInput) {
             if (!newPattern.notebookInfo) {
                 newPattern.notebookInfo = {};

package/dist/vscode/vs/workbench/services/search/common/replace.js

@@ -0,0 +1,203 @@
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { buildReplaceStringWithCasePreserved } from 'monaco-editor/esm/vs/base/common/search.js';
+class ReplacePattern {
+    constructor(replaceString, arg2, arg3) {
+        this._hasParameters = false;
+        this._replacePattern = replaceString;
+        let searchPatternInfo;
+        let parseParameters;
+        if (typeof arg2 === 'boolean') {
+            parseParameters = arg2;
+            this._regExp = arg3;
+        }
+        else {
+            searchPatternInfo = arg2;
+            parseParameters = !!searchPatternInfo.isRegExp;
+            this._regExp = strings.createRegExp(searchPatternInfo.pattern, !!searchPatternInfo.isRegExp, { matchCase: searchPatternInfo.isCaseSensitive, wholeWord: searchPatternInfo.isWordMatch, multiline: searchPatternInfo.isMultiline, global: false, unicode: true });
+        }
+        if (parseParameters) {
+            this.parseReplaceString(replaceString);
+        }
+        if (this._regExp.global) {
+            this._regExp = strings.createRegExp(this._regExp.source, true, { matchCase: !this._regExp.ignoreCase, wholeWord: false, multiline: this._regExp.multiline, global: false });
+        }
+        this._caseOpsRegExp = ( new RegExp(/([\s\S]*?)((?:\\[uUlL])+?|)(\$[0-9]+)([\s\S]*?)/g));
+    }
+    get hasParameters() {
+        return this._hasParameters;
+    }
+    get pattern() {
+        return this._replacePattern;
+    }
+    get regExp() {
+        return this._regExp;
+    }
+    getReplaceString(text, preserveCase) {
+        this._regExp.lastIndex = 0;
+        const match = this._regExp.exec(text);
+        if (match) {
+            if (this.hasParameters) {
+                const replaceString = this.replaceWithCaseOperations(text, this._regExp, this.buildReplaceString(match, preserveCase));
+                if (match[0] === text) {
+                    return replaceString;
+                }
+                return replaceString.substr(match.index, match[0].length - (text.length - replaceString.length));
+            }
+            return this.buildReplaceString(match, preserveCase);
+        }
+        return null;
+    }
+    replaceWithCaseOperations(text, regex, replaceString) {
+        if (!/\\[uUlL]/.test(replaceString)) {
+            return text.replace(regex, replaceString);
+        }
+        const firstMatch = regex.exec(text);
+        if (firstMatch === null) {
+            return text.replace(regex, replaceString);
+        }
+        let patMatch;
+        let newReplaceString = '';
+        let lastIndex = 0;
+        let lastMatch = '';
+        while ((patMatch = this._caseOpsRegExp.exec(replaceString)) !== null) {
+            lastIndex = patMatch.index;
+            const fullMatch = patMatch[0];
+            lastMatch = fullMatch;
+            let caseOps = patMatch[2];
+            const money = patMatch[3];
+            if (!caseOps) {
+                newReplaceString += fullMatch;
+                continue;
+            }
+            const replacement = firstMatch[parseInt(money.slice(1))];
+            if (!replacement) {
+                newReplaceString += fullMatch;
+                continue;
+            }
+            const replacementLen = replacement.length;
+            newReplaceString += patMatch[1];
+            caseOps = caseOps.replace(/\\/g, '');
+            let i = 0;
+            for (; i < caseOps.length; i++) {
+                switch (caseOps[i]) {
+                    case 'U':
+                        newReplaceString += replacement.slice(i).toUpperCase();
+                        i = replacementLen;
+                        break;
+                    case 'u':
+                        newReplaceString += replacement[i].toUpperCase();
+                        break;
+                    case 'L':
+                        newReplaceString += replacement.slice(i).toLowerCase();
+                        i = replacementLen;
+                        break;
+                    case 'l':
+                        newReplaceString += replacement[i].toLowerCase();
+                        break;
+                }
+            }
+            if (i < replacementLen) {
+                newReplaceString += replacement.slice(i);
+            }
+            newReplaceString += patMatch[4];
+        }
+        newReplaceString += replaceString.slice(lastIndex + lastMatch.length);
+        return text.replace(regex, newReplaceString);
+    }
+    buildReplaceString(matches, preserveCase) {
+        if (preserveCase) {
+            return buildReplaceStringWithCasePreserved(matches, this._replacePattern);
+        }
+        else {
+            return this._replacePattern;
+        }
+    }
+    parseReplaceString(replaceString) {
+        if (!replaceString || replaceString.length === 0) {
+            return;
+        }
+        let substrFrom = 0, result = '';
+        for (let i = 0, len = replaceString.length; i < len; i++) {
+            const chCode = replaceString.charCodeAt(i);
+            if (chCode === 92 ) {
+                i++;
+                if (i >= len) {
+                    break;
+                }
+                const nextChCode = replaceString.charCodeAt(i);
+                let replaceWithCharacter = null;
+                switch (nextChCode) {
+                    case 92 :
+                        replaceWithCharacter = '\\';
+                        break;
+                    case 110 :
+                        replaceWithCharacter = '\n';
+                        break;
+                    case 116 :
+                        replaceWithCharacter = '\t';
+                        break;
+                }
+                if (replaceWithCharacter) {
+                    result += replaceString.substring(substrFrom, i - 1) + replaceWithCharacter;
+                    substrFrom = i + 1;
+                }
+            }
+            if (chCode === 36 ) {
+                i++;
+                if (i >= len) {
+                    break;
+                }
+                const nextChCode = replaceString.charCodeAt(i);
+                let replaceWithCharacter = null;
+                switch (nextChCode) {
+                    case 48 :
+                        replaceWithCharacter = '$&';
+                        this._hasParameters = true;
+                        break;
+                    case 96 :
+                    case 39 :
+                        this._hasParameters = true;
+                        break;
+                    default: {
+                        if (!this.between(nextChCode, 49 , 57 )) {
+                            break;
+                        }
+                        if (i === replaceString.length - 1) {
+                            this._hasParameters = true;
+                            break;
+                        }
+                        let charCode = replaceString.charCodeAt(++i);
+                        if (!this.between(charCode, 48 , 57 )) {
+                            this._hasParameters = true;
+                            --i;
+                            break;
+                        }
+                        if (i === replaceString.length - 1) {
+                            this._hasParameters = true;
+                            break;
+                        }
+                        charCode = replaceString.charCodeAt(++i);
+                        if (!this.between(charCode, 48 , 57 )) {
+                            this._hasParameters = true;
+                            --i;
+                            break;
+                        }
+                        break;
+                    }
+                }
+                if (replaceWithCharacter) {
+                    result += replaceString.substring(substrFrom, i - 1) + replaceWithCharacter;
+                    substrFrom = i + 1;
+                }
+            }
+        }
+        if (substrFrom === 0) {
+            return;
+        }
+        this._replacePattern = result + replaceString.substring(substrFrom);
+    }
+    between(value, from, to) {
+        return from <= value && value <= to;
+    }
+}
+export { ReplacePattern };