/*!--------------------------------------------------------
 * Copyright (C) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------*/
(function() {
var __m = ["require","exports","vs/base/common/amd","vs/amdX","vs/workbench/services/languageDetection/browser/languageDetectionWorker.protocol","vs/base/common/network","vs/base/common/platform","vs/base/common/types","vs/base/common/uri","vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker","vs/base/common/stopwatch","vs/editor/common/services/textModelSync/textModelSync.impl"];
var __M = function(deps) {
  var result = [];
  for (var i = 0, len = deps.length; i < len; i++) {
    result[i] = __m[deps[i]];
  }
  return result;
};
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[2/*vs/base/common/amd*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$X = exports.LoaderEventType = exports.$W = exports.$V = void 0;
    // ESM-comment-begin
    exports.$V = false;
    exports.$W = true;
    // ESM-comment-end
    // ESM-uncomment-begin
    // export const isESM = true;
    // export const canASAR = false; // TODO@esm: ASAR disabled in ESM
    // ESM-uncomment-end
    var LoaderEventType;
    (function (LoaderEventType) {
        LoaderEventType[LoaderEventType["LoaderAvailable"] = 1] = "LoaderAvailable";
        LoaderEventType[LoaderEventType["BeginLoadingScript"] = 10] = "BeginLoadingScript";
        LoaderEventType[LoaderEventType["EndLoadingScriptOK"] = 11] = "EndLoadingScriptOK";
        LoaderEventType[LoaderEventType["EndLoadingScriptError"] = 12] = "EndLoadingScriptError";
        LoaderEventType[LoaderEventType["BeginInvokeFactory"] = 21] = "BeginInvokeFactory";
        LoaderEventType[LoaderEventType["EndInvokeFactory"] = 22] = "EndInvokeFactory";
        LoaderEventType[LoaderEventType["NodeBeginEvaluatingScript"] = 31] = "NodeBeginEvaluatingScript";
        LoaderEventType[LoaderEventType["NodeEndEvaluatingScript"] = 32] = "NodeEndEvaluatingScript";
        LoaderEventType[LoaderEventType["NodeBeginNativeRequire"] = 33] = "NodeBeginNativeRequire";
        LoaderEventType[LoaderEventType["NodeEndNativeRequire"] = 34] = "NodeEndNativeRequire";
        LoaderEventType[LoaderEventType["CachedDataFound"] = 60] = "CachedDataFound";
        LoaderEventType[LoaderEventType["CachedDataMissed"] = 61] = "CachedDataMissed";
        LoaderEventType[LoaderEventType["CachedDataRejected"] = 62] = "CachedDataRejected";
        LoaderEventType[LoaderEventType["CachedDataCreated"] = 63] = "CachedDataCreated";
    })(LoaderEventType || (exports.LoaderEventType = LoaderEventType = {}));
    class $X {
        static get() {
            const amdLoadScript = new Map();
            const amdInvokeFactory = new Map();
            const nodeRequire = new Map();
            const nodeEval = new Map();
            function mark(map, stat) {
                if (map.has(stat.detail)) {
                    // console.warn('BAD events, DOUBLE start', stat);
                    // map.delete(stat.detail);
                    return;
                }
                map.set(stat.detail, -stat.timestamp);
            }
            function diff(map, stat) {
                const duration = map.get(stat.detail);
                if (!duration) {
                    // console.warn('BAD events, end WITHOUT start', stat);
                    // map.delete(stat.detail);
                    return;
                }
                if (duration >= 0) {
                    // console.warn('BAD events, DOUBLE end', stat);
                    // map.delete(stat.detail);
                    return;
                }
                map.set(stat.detail, duration + stat.timestamp);
            }
            let stats = [];
            if (typeof require === 'function' && typeof require.getStats === 'function') {
                stats = require.getStats().slice(0).sort((a, b) => a.timestamp - b.timestamp);
            }
            for (const stat of stats) {
                switch (stat.type) {
                    case LoaderEventType.BeginLoadingScript:
                        mark(amdLoadScript, stat);
                        break;
                    case LoaderEventType.EndLoadingScriptOK:
                    case LoaderEventType.EndLoadingScriptError:
                        diff(amdLoadScript, stat);
                        break;
                    case LoaderEventType.BeginInvokeFactory:
                        mark(amdInvokeFactory, stat);
                        break;
                    case LoaderEventType.EndInvokeFactory:
                        diff(amdInvokeFactory, stat);
                        break;
                    case LoaderEventType.NodeBeginNativeRequire:
                        mark(nodeRequire, stat);
                        break;
                    case LoaderEventType.NodeEndNativeRequire:
                        diff(nodeRequire, stat);
                        break;
                    case LoaderEventType.NodeBeginEvaluatingScript:
                        mark(nodeEval, stat);
                        break;
                    case LoaderEventType.NodeEndEvaluatingScript:
                        diff(nodeEval, stat);
                        break;
                }
            }
            let nodeRequireTotal = 0;
            nodeRequire.forEach(value => nodeRequireTotal += value);
            function to2dArray(map) {
                const res = [];
                map.forEach((value, index) => res.push([index, value]));
                return res;
            }
            return {
                amdLoad: to2dArray(amdLoadScript),
                amdInvoke: to2dArray(amdInvokeFactory),
                nodeRequire: to2dArray(nodeRequire),
                nodeEval: to2dArray(nodeEval),
                nodeRequireTotal
            };
        }
        static toMarkdownTable(header, rows) {
            let result = '';
            const lengths = [];
            header.forEach((cell, ci) => {
                lengths[ci] = cell.length;
            });
            rows.forEach(row => {
                row.forEach((cell, ci) => {
                    if (typeof cell === 'undefined') {
                        cell = row[ci] = '-';
                    }
                    const len = cell.toString().length;
                    lengths[ci] = Math.max(len, lengths[ci]);
                });
            });
            // header
            header.forEach((cell, ci) => { result += `| ${cell + ' '.repeat(lengths[ci] - cell.toString().length)} `; });
            result += '|\n';
            header.forEach((_cell, ci) => { result += `| ${'-'.repeat(lengths[ci])} `; });
            result += '|\n';
            // cells
            rows.forEach(row => {
                row.forEach((cell, ci) => {
                    if (typeof cell !== 'undefined') {
                        result += `| ${cell + ' '.repeat(lengths[ci] - cell.toString().length)} `;
                    }
                });
                result += '|\n';
            });
            return result;
        }
    }
    exports.$X = $X;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
define(__m[3/*vs/amdX*/], __M([0/*require*/,1/*exports*/,2/*vs/base/common/amd*/,5/*vs/base/common/network*/,6/*vs/base/common/platform*/,7/*vs/base/common/types*/,8/*vs/base/common/uri*/]), function (require, exports, amd_1, network_1, platform, types_1, uri_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$zq = $zq;
    exports.$Aq = $Aq;
    platform = __importStar(platform);
    class DefineCall {
        constructor(id, dependencies, callback) {
            this.id = id;
            this.dependencies = dependencies;
            this.callback = callback;
        }
    }
    class AMDModuleImporter {
        static { this.INSTANCE = new AMDModuleImporter(); }
        constructor() {
            this.a = (typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope');
            this.b = typeof document === 'object';
            this.c = [];
            this.d = false;
        }
        g() {
            if (this.d) {
                return;
            }
            this.d = true;
            globalThis.define = (id, dependencies, callback) => {
                if (typeof id !== 'string') {
                    callback = dependencies;
                    dependencies = id;
                    id = null;
                }
                if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {
                    callback = dependencies;
                    dependencies = null;
                }
                // if (!dependencies) {
                // 	dependencies = ['require', 'exports', 'module'];
                // }
                this.c.push(new DefineCall(id, dependencies, callback));
            };
            globalThis.define.amd = true;
            if (this.b) {
                // eslint-disable-next-line no-restricted-globals
                this.f = globalThis._VSCODE_WEB_PACKAGE_TTP ?? window.trustedTypes?.createPolicy('amdLoader', {
                    createScriptURL(value) {
                        // eslint-disable-next-line no-restricted-globals
                        if (value.startsWith(window.location.origin)) {
                            return value;
                        }
                        if (value.startsWith(`${network_1.Schemas.vscodeFileResource}://${network_1.$4g}`)) {
                            return value;
                        }
                        throw new Error(`[trusted_script_src] Invalid script url: ${value}`);
                    }
                });
            }
            else if (this.a) {
                this.f = globalThis._VSCODE_WEB_PACKAGE_TTP ?? globalThis.trustedTypes?.createPolicy('amdLoader', {
                    createScriptURL(value) {
                        return value;
                    }
                });
            }
        }
        async load(scriptSrc) {
            this.g();
            const defineCall = await (this.a ? this.i(scriptSrc) : this.b ? this.h(scriptSrc) : this.j(scriptSrc));
            if (!defineCall) {
                // throw new Error(`Did not receive a define call from script ${scriptSrc}`);
                console.warn(`Did not receive a define call from script ${scriptSrc}`);
                return undefined;
            }
            // TODO require, module
            const exports = {};
            const dependencyObjs = [];
            const dependencyModules = [];
            if (Array.isArray(defineCall.dependencies)) {
                for (const mod of defineCall.dependencies) {
                    if (mod === 'exports') {
                        dependencyObjs.push(exports);
                    }
                    else {
                        dependencyModules.push(mod);
                    }
                }
            }
            if (dependencyModules.length > 0) {
                throw new Error(`Cannot resolve dependencies for script ${scriptSrc}. The dependencies are: ${dependencyModules.join(', ')}`);
            }
            if (typeof defineCall.callback === 'function') {
                return defineCall.callback(...dependencyObjs) ?? exports;
            }
            else {
                return defineCall.callback;
            }
        }
        h(scriptSrc) {
            return new Promise((resolve, reject) => {
                const scriptElement = document.createElement('script');
                scriptElement.setAttribute('async', 'async');
                scriptElement.setAttribute('type', 'text/javascript');
                const unbind = () => {
                    scriptElement.removeEventListener('load', loadEventListener);
                    scriptElement.removeEventListener('error', errorEventListener);
                };
                const loadEventListener = (e) => {
                    unbind();
                    resolve(this.c.pop());
                };
                const errorEventListener = (e) => {
                    unbind();
                    reject(e);
                };
                scriptElement.addEventListener('load', loadEventListener);
                scriptElement.addEventListener('error', errorEventListener);
                if (this.f) {
                    scriptSrc = this.f.createScriptURL(scriptSrc);
                }
                scriptElement.setAttribute('src', scriptSrc);
                // eslint-disable-next-line no-restricted-globals
                window.document.getElementsByTagName('head')[0].appendChild(scriptElement);
            });
        }
        async i(scriptSrc) {
            if (this.f) {
                scriptSrc = this.f.createScriptURL(scriptSrc);
            }
            if (amd_1.$V) {
                await new Promise((resolve_1, reject_1) => { require([scriptSrc], resolve_1, reject_1); }).then(__importStar);
            }
            else {
                importScripts(scriptSrc);
            }
            return this.c.pop();
        }
        async j(scriptSrc) {
            try {
                const fs = globalThis._VSCODE_NODE_MODULES['fs'];
                const vm = globalThis._VSCODE_NODE_MODULES['vm'];
                const module = globalThis._VSCODE_NODE_MODULES['module'];
                const filePath = uri_1.URI.parse(scriptSrc).fsPath;
                const content = fs.readFileSync(filePath).toString();
                const scriptSource = module.wrap(content.replace(/^#!.*/, ''));
                const script = new vm.Script(scriptSource);
                const compileWrapper = script.runInThisContext();
                compileWrapper.apply();
                return this.c.pop();
            }
            catch (error) {
                throw error;
            }
        }
    }
    const cache = new Map();
    /**
     * Utility for importing an AMD node module. This util supports AMD and ESM contexts and should be used while the ESM adoption
     * is on its way.
     *
     * e.g. pass in `vscode-textmate/release/main.js`
     */
    async function $zq(nodeModuleName, pathInsideNodeModule, isBuilt) {
        if (amd_1.$V) {
            if (isBuilt === undefined) {
                const product = globalThis._VSCODE_PRODUCT_JSON;
                isBuilt = Boolean((product ?? globalThis.vscode?.context?.configuration()?.product)?.commit);
            }
            const nodeModulePath = pathInsideNodeModule ? `${nodeModuleName}/${pathInsideNodeModule}` : nodeModuleName;
            if (cache.has(nodeModulePath)) {
                return cache.get(nodeModulePath);
            }
            let scriptSrc;
            if (/^\w[\w\d+.-]*:\/\//.test(nodeModulePath)) {
                // looks like a URL
                // bit of a special case for: src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.ts
                scriptSrc = nodeModulePath;
            }
            else {
                const useASAR = (amd_1.$W && isBuilt && !platform.$r);
                const actualNodeModulesPath = (useASAR ? network_1.$2g : network_1.$1g);
                const resourcePath = `${actualNodeModulesPath}/${nodeModulePath}`;
                scriptSrc = network_1.$5g.asBrowserUri(resourcePath).toString(true);
            }
            const result = AMDModuleImporter.INSTANCE.load(scriptSrc);
            cache.set(nodeModulePath, result);
            return result;
        }
        else {
            return await new Promise((resolve_2, reject_2) => { require([nodeModuleName], resolve_2, reject_2); }).then(__importStar);
        }
    }
    function $Aq(nodeModuleName, pathInsideNodeModule) {
        (0, types_1.$tg)(amd_1.$V);
        const product = globalThis._VSCODE_PRODUCT_JSON;
        const isBuilt = Boolean((product ?? globalThis.vscode?.context?.configuration()?.product)?.commit);
        const useASAR = (amd_1.$W && isBuilt && !platform.$r);
        const nodeModulePath = `${nodeModuleName}/${pathInsideNodeModule}`;
        const actualNodeModulesPath = (useASAR ? network_1.$2g : network_1.$1g);
        const resourcePath = `${actualNodeModulesPath}/${nodeModulePath}`;
        return network_1.$5g.asBrowserUri(resourcePath).toString(true);
    }
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[4/*vs/workbench/services/languageDetection/browser/languageDetectionWorker.protocol*/], __M([0/*require*/,1/*exports*/]), function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.$uPb = void 0;
    class $uPb {
        static { this.CHANNEL_NAME = 'languageDetectionWorkerHost'; }
        static getChannel(workerServer) {
            return workerServer.getChannel($uPb.CHANNEL_NAME);
        }
        static setChannel(workerClient, obj) {
            workerClient.setChannel($uPb.CHANNEL_NAME, obj);
        }
    }
    exports.$uPb = $uPb;
});

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
define(__m[9/*vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker*/], __M([0/*require*/,1/*exports*/,3/*vs/amdX*/,10/*vs/base/common/stopwatch*/,4/*vs/workbench/services/languageDetection/browser/languageDetectionWorker.protocol*/,11/*vs/editor/common/services/textModelSync/textModelSync.impl*/]), function (require, exports, amdX_1, stopwatch_1, languageDetectionWorker_protocol_1, textModelSync_impl_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.LanguageDetectionSimpleWorker = void 0;
    exports.create = create;
    /**
     * Defines the worker entry point. Must be exported and named `create`.
     * @skipMangle
     */
    function create(workerServer) {
        return new LanguageDetectionSimpleWorker(workerServer);
    }
    /**
     * @internal
     */
    class LanguageDetectionSimpleWorker {
        static { this.a = 0.2; }
        static { this.b = 0.05; }
        static { this.c = 0.025; }
        static { this.d = 0.5; }
        constructor(workerServer) {
            this.f = new textModelSync_impl_1.$N5();
            this.i = false;
            this.k = false;
            this.l = new Map();
            this.g = languageDetectionWorker_protocol_1.$uPb.getChannel(workerServer);
            this.f.bindToServer(workerServer);
        }
        async $detectLanguage(uri, langBiases, preferHistory, supportedLangs) {
            const languages = [];
            const confidences = [];
            const stopWatch = new stopwatch_1.$ke();
            const documentTextSample = this.m(uri);
            if (!documentTextSample) {
                return;
            }
            const neuralResolver = async () => {
                for await (const language of this.r(documentTextSample)) {
                    if (!this.l.has(language.languageId)) {
                        this.l.set(language.languageId, await this.g.$getLanguageId(language.languageId));
                    }
                    const coreId = this.l.get(language.languageId);
                    if (coreId && (!supportedLangs?.length || supportedLangs.includes(coreId))) {
                        languages.push(coreId);
                        confidences.push(language.confidence);
                    }
                }
                stopWatch.stop();
                if (languages.length) {
                    this.g.$sendTelemetryEvent(languages, confidences, stopWatch.elapsed());
                    return languages[0];
                }
                return undefined;
            };
            const historicalResolver = async () => this.o(documentTextSample, langBiases ?? {}, supportedLangs);
            if (preferHistory) {
                const history = await historicalResolver();
                if (history) {
                    return history;
                }
                const neural = await neuralResolver();
                if (neural) {
                    return neural;
                }
            }
            else {
                const neural = await neuralResolver();
                if (neural) {
                    return neural;
                }
                const history = await historicalResolver();
                if (history) {
                    return history;
                }
            }
            return undefined;
        }
        m(uri) {
            const editorModel = this.f.getModel(uri);
            if (!editorModel) {
                return;
            }
            const end = editorModel.positionAt(10000);
            const content = editorModel.getValueInRange({
                startColumn: 1,
                startLineNumber: 1,
                endColumn: end.column,
                endLineNumber: end.lineNumber
            });
            return content;
        }
        async n() {
            if (this.i) {
                return;
            }
            if (this.h) {
                return this.h;
            }
            const uri = await this.g.$getRegexpModelUri();
            try {
                this.h = await (0, amdX_1.$zq)(uri, '');
                return this.h;
            }
            catch (e) {
                this.i = true;
                // console.warn('error loading language detection model', e);
                return;
            }
        }
        async o(content, langBiases, supportedLangs) {
            const regexpModel = await this.n();
            if (!regexpModel) {
                return;
            }
            if (supportedLangs?.length) {
                // When using supportedLangs, normally computed biases are too extreme. Just use a "bitmask" of sorts.
                for (const lang of Object.keys(langBiases)) {
                    if (supportedLangs.includes(lang)) {
                        langBiases[lang] = 1;
                    }
                    else {
                        langBiases[lang] = 0;
                    }
                }
            }
            const detected = regexpModel.detect(content, langBiases, supportedLangs);
            return detected;
        }
        async p() {
            if (this.j) {
                return this.j;
            }
            const uri = await this.g.$getIndexJsUri();
            const { ModelOperations } = await (0, amdX_1.$zq)(uri, '');
            this.j = new ModelOperations({
                modelJsonLoaderFunc: async () => {
                    const response = await fetch(await this.g.$getModelJsonUri());
                    try {
                        const modelJSON = await response.json();
                        return modelJSON;
                    }
                    catch (e) {
                        const message = `Failed to parse model JSON.`;
                        throw new Error(message);
                    }
                },
                weightsLoaderFunc: async () => {
                    const response = await fetch(await this.g.$getWeightsUri());
                    const buffer = await response.arrayBuffer();
                    return buffer;
                }
            });
            return this.j;
        }
        // This adjusts the language confidence scores to be more accurate based on:
        // * VS Code's language usage
        // * Languages with 'problematic' syntaxes that have caused incorrect language detection
        q(modelResult) {
            switch (modelResult.languageId) {
                // For the following languages, we increase the confidence because
                // these are commonly used languages in VS Code and supported
                // by the model.
                case 'js':
                case 'html':
                case 'json':
                case 'ts':
                case 'css':
                case 'py':
                case 'xml':
                case 'php':
                    modelResult.confidence += LanguageDetectionSimpleWorker.b;
                    break;
                // case 'yaml': // YAML has been know to cause incorrect language detection because the language is pretty simple. We don't want to increase the confidence for this.
                case 'cpp':
                case 'sh':
                case 'java':
                case 'cs':
                case 'c':
                    modelResult.confidence += LanguageDetectionSimpleWorker.c;
                    break;
                // For the following languages, we need to be extra confident that the language is correct because
                // we've had issues like #131912 that caused incorrect guesses. To enforce this, we subtract the
                // negativeConfidenceCorrection from the confidence.
                // languages that are provided by default in VS Code
                case 'bat':
                case 'ini':
                case 'makefile':
                case 'sql':
                // languages that aren't provided by default in VS Code
                case 'csv':
                case 'toml':
                    // Other considerations for negativeConfidenceCorrection that
                    // aren't built in but suported by the model include:
                    // * Assembly, TeX - These languages didn't have clear language modes in the community
                    // * Markdown, Dockerfile - These languages are simple but they embed other languages
                    modelResult.confidence -= LanguageDetectionSimpleWorker.d;
                    break;
                default:
                    break;
            }
            return modelResult;
        }
        async *r(content) {
            if (this.k) {
                return;
            }
            let modelOperations;
            try {
                modelOperations = await this.p();
            }
            catch (e) {
                console.log(e);
                this.k = true;
                return;
            }
            let modelResults;
            try {
                modelResults = await modelOperations.runModel(content);
            }
            catch (e) {
                console.warn(e);
            }
            if (!modelResults
                || modelResults.length === 0
                || modelResults[0].confidence < LanguageDetectionSimpleWorker.a) {
                return;
            }
            const firstModelResult = this.q(modelResults[0]);
            if (firstModelResult.confidence < LanguageDetectionSimpleWorker.a) {
                return;
            }
            const possibleLanguages = [firstModelResult];
            for (let current of modelResults) {
                if (current === firstModelResult) {
                    continue;
                }
                current = this.q(current);
                const currentHighest = possibleLanguages[possibleLanguages.length - 1];
                if (currentHighest.confidence - current.confidence >= LanguageDetectionSimpleWorker.a) {
                    while (possibleLanguages.length) {
                        yield possibleLanguages.shift();
                    }
                    if (current.confidence > LanguageDetectionSimpleWorker.a) {
                        possibleLanguages.push(current);
                        continue;
                    }
                    return;
                }
                else {
                    if (current.confidence > LanguageDetectionSimpleWorker.a) {
                        possibleLanguages.push(current);
                        continue;
                    }
                    return;
                }
            }
        }
    }
    exports.LanguageDetectionSimpleWorker = LanguageDetectionSimpleWorker;
});

}).call(this);
//# sourceMappingURL=languageDetectionSimpleWorker.js.map
