|
|
@@ -1,11515 +0,0 @@
|
|
|
-/*!-----------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Version: 0.9.0(630109944f54bcdfc2dbaaff5f090c0843af6c66)
|
|
|
- * Released under the MIT license
|
|
|
- * https://github.com/Microsoft/vscode/blob/master/LICENSE.txt
|
|
|
- *-----------------------------------------------------------*/
|
|
|
-
|
|
|
-(function() {
|
|
|
-var __m = ["exports","require","vs/base/common/winjs.base","vs/editor/common/core/position","vs/base/common/platform","vs/editor/common/core/range","vs/base/common/uri","vs/editor/common/core/uint","vs/base/common/errors","vs/base/common/event","vs/base/common/lifecycle","vs/base/common/functional","vs/base/common/diff/diff","vs/base/common/cancellation","vs/base/common/types","vs/base/common/callbackList","vs/base/common/diff/diffChange","vs/base/common/map","vs/base/common/async","vs/editor/common/viewModel/prefixSumComputer","vs/base/common/strings","vs/base/common/keyCodes","vs/editor/common/core/selection","vs/editor/common/core/token","vs/editor/common/model/mirrorModel","vs/editor/common/core/characterClassifier","vs/editor/common/diff/diffComputer","vs/editor/common/model/wordHelper","vs/editor/common/modes/linkComputer","vs/editor/common/modes/supports/inplaceReplaceSupport","vs/editor/common/standalone/standaloneBase","vs/base/common/worker/simpleWorker","vs/base/common/winjs.base.raw","vs/editor/common/services/editorSimpleWorker"];
|
|
|
-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.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-'use strict';
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- * Please make sure to make edits in the .ts file at https://github.com/Microsoft/vscode-loader/
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *---------------------------------------------------------------------------------------------
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var _amdLoaderGlobal = this;
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- AMDLoader.global = _amdLoaderGlobal;
|
|
|
- var Environment = (function () {
|
|
|
- function Environment(opts) {
|
|
|
- this.isWindows = opts.isWindows;
|
|
|
- this.isNode = opts.isNode;
|
|
|
- this.isElectronRenderer = opts.isElectronRenderer;
|
|
|
- this.isWebWorker = opts.isWebWorker;
|
|
|
- }
|
|
|
- Environment.detect = function () {
|
|
|
- return new Environment({
|
|
|
- isWindows: this._isWindows(),
|
|
|
- isNode: (typeof module !== 'undefined' && !!module.exports),
|
|
|
- isElectronRenderer: (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer'),
|
|
|
- isWebWorker: (typeof AMDLoader.global.importScripts === 'function')
|
|
|
- });
|
|
|
- };
|
|
|
- Environment._isWindows = function () {
|
|
|
- if (typeof navigator !== 'undefined') {
|
|
|
- if (navigator.userAgent && navigator.userAgent.indexOf('Windows') >= 0) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (typeof process !== 'undefined') {
|
|
|
- return (process.platform === 'win32');
|
|
|
- }
|
|
|
- return false;
|
|
|
- };
|
|
|
- return Environment;
|
|
|
- }());
|
|
|
- AMDLoader.Environment = Environment;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- 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 = AMDLoader.LoaderEventType || (AMDLoader.LoaderEventType = {}));
|
|
|
- var LoaderEvent = (function () {
|
|
|
- function LoaderEvent(type, detail, timestamp) {
|
|
|
- this.type = type;
|
|
|
- this.detail = detail;
|
|
|
- this.timestamp = timestamp;
|
|
|
- }
|
|
|
- return LoaderEvent;
|
|
|
- }());
|
|
|
- AMDLoader.LoaderEvent = LoaderEvent;
|
|
|
- var LoaderEventRecorder = (function () {
|
|
|
- function LoaderEventRecorder(loaderAvailableTimestamp) {
|
|
|
- this._events = [new LoaderEvent(LoaderEventType.LoaderAvailable, '', loaderAvailableTimestamp)];
|
|
|
- }
|
|
|
- LoaderEventRecorder.prototype.record = function (type, detail) {
|
|
|
- this._events.push(new LoaderEvent(type, detail, AMDLoader.Utilities.getHighPerformanceTimestamp()));
|
|
|
- };
|
|
|
- LoaderEventRecorder.prototype.getEvents = function () {
|
|
|
- return this._events;
|
|
|
- };
|
|
|
- return LoaderEventRecorder;
|
|
|
- }());
|
|
|
- AMDLoader.LoaderEventRecorder = LoaderEventRecorder;
|
|
|
- var NullLoaderEventRecorder = (function () {
|
|
|
- function NullLoaderEventRecorder() {
|
|
|
- }
|
|
|
- NullLoaderEventRecorder.prototype.record = function (type, detail) {
|
|
|
- // Nothing to do
|
|
|
- };
|
|
|
- NullLoaderEventRecorder.prototype.getEvents = function () {
|
|
|
- return [];
|
|
|
- };
|
|
|
- return NullLoaderEventRecorder;
|
|
|
- }());
|
|
|
- NullLoaderEventRecorder.INSTANCE = new NullLoaderEventRecorder();
|
|
|
- AMDLoader.NullLoaderEventRecorder = NullLoaderEventRecorder;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- var Utilities = (function () {
|
|
|
- function Utilities() {
|
|
|
- }
|
|
|
- /**
|
|
|
- * This method does not take care of / vs \
|
|
|
- */
|
|
|
- Utilities.fileUriToFilePath = function (isWindows, uri) {
|
|
|
- uri = decodeURI(uri);
|
|
|
- if (isWindows) {
|
|
|
- if (/^file:\/\/\//.test(uri)) {
|
|
|
- // This is a URI without a hostname => return only the path segment
|
|
|
- return uri.substr(8);
|
|
|
- }
|
|
|
- if (/^file:\/\//.test(uri)) {
|
|
|
- return uri.substr(5);
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- if (/^file:\/\//.test(uri)) {
|
|
|
- return uri.substr(7);
|
|
|
- }
|
|
|
- }
|
|
|
- // Not sure...
|
|
|
- return uri;
|
|
|
- };
|
|
|
- Utilities.startsWith = function (haystack, needle) {
|
|
|
- return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
|
|
|
- };
|
|
|
- Utilities.endsWith = function (haystack, needle) {
|
|
|
- return haystack.length >= needle.length && haystack.substr(haystack.length - needle.length) === needle;
|
|
|
- };
|
|
|
- // only check for "?" before "#" to ensure that there is a real Query-String
|
|
|
- Utilities.containsQueryString = function (url) {
|
|
|
- return /^[^\#]*\?/gi.test(url);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Does `url` start with http:// or https:// or file:// or / ?
|
|
|
- */
|
|
|
- Utilities.isAbsolutePath = function (url) {
|
|
|
- return /^((http:\/\/)|(https:\/\/)|(file:\/\/)|(\/))/.test(url);
|
|
|
- };
|
|
|
- Utilities.forEachProperty = function (obj, callback) {
|
|
|
- if (obj) {
|
|
|
- var key = void 0;
|
|
|
- for (key in obj) {
|
|
|
- if (obj.hasOwnProperty(key)) {
|
|
|
- callback(key, obj[key]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- Utilities.isEmpty = function (obj) {
|
|
|
- var isEmpty = true;
|
|
|
- Utilities.forEachProperty(obj, function () {
|
|
|
- isEmpty = false;
|
|
|
- });
|
|
|
- return isEmpty;
|
|
|
- };
|
|
|
- Utilities.recursiveClone = function (obj) {
|
|
|
- if (!obj || typeof obj !== 'object') {
|
|
|
- return obj;
|
|
|
- }
|
|
|
- var result = Array.isArray(obj) ? [] : {};
|
|
|
- Utilities.forEachProperty(obj, function (key, value) {
|
|
|
- if (value && typeof value === 'object') {
|
|
|
- result[key] = Utilities.recursiveClone(value);
|
|
|
- }
|
|
|
- else {
|
|
|
- result[key] = value;
|
|
|
- }
|
|
|
- });
|
|
|
- return result;
|
|
|
- };
|
|
|
- Utilities.generateAnonymousModule = function () {
|
|
|
- return '===anonymous' + (Utilities.NEXT_ANONYMOUS_ID++) + '===';
|
|
|
- };
|
|
|
- Utilities.isAnonymousModule = function (id) {
|
|
|
- return /^===anonymous/.test(id);
|
|
|
- };
|
|
|
- Utilities.getHighPerformanceTimestamp = function () {
|
|
|
- if (!this.PERFORMANCE_NOW_PROBED) {
|
|
|
- this.PERFORMANCE_NOW_PROBED = true;
|
|
|
- this.HAS_PERFORMANCE_NOW = (AMDLoader.global.performance && typeof AMDLoader.global.performance.now === 'function');
|
|
|
- }
|
|
|
- return (this.HAS_PERFORMANCE_NOW ? AMDLoader.global.performance.now() : Date.now());
|
|
|
- };
|
|
|
- return Utilities;
|
|
|
- }());
|
|
|
- Utilities.NEXT_ANONYMOUS_ID = 1;
|
|
|
- Utilities.PERFORMANCE_NOW_PROBED = false;
|
|
|
- Utilities.HAS_PERFORMANCE_NOW = false;
|
|
|
- AMDLoader.Utilities = Utilities;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- var ConfigurationOptionsUtil = (function () {
|
|
|
- function ConfigurationOptionsUtil() {
|
|
|
- }
|
|
|
- /**
|
|
|
- * Ensure configuration options make sense
|
|
|
- */
|
|
|
- ConfigurationOptionsUtil.validateConfigurationOptions = function (isWebWorker, options) {
|
|
|
- function defaultOnError(err) {
|
|
|
- if (err.errorCode === 'load') {
|
|
|
- console.error('Loading "' + err.moduleId + '" failed');
|
|
|
- console.error('Detail: ', err.detail);
|
|
|
- if (err.detail && err.detail.stack) {
|
|
|
- console.error(err.detail.stack);
|
|
|
- }
|
|
|
- console.error('Here are the modules that depend on it:');
|
|
|
- console.error(err.neededBy);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (err.errorCode === 'factory') {
|
|
|
- console.error('The factory method of "' + err.moduleId + '" has thrown an exception');
|
|
|
- console.error(err.detail);
|
|
|
- if (err.detail && err.detail.stack) {
|
|
|
- console.error(err.detail.stack);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- options = options || {};
|
|
|
- if (typeof options.baseUrl !== 'string') {
|
|
|
- options.baseUrl = '';
|
|
|
- }
|
|
|
- if (typeof options.isBuild !== 'boolean') {
|
|
|
- options.isBuild = false;
|
|
|
- }
|
|
|
- if (typeof options.paths !== 'object') {
|
|
|
- options.paths = {};
|
|
|
- }
|
|
|
- if (typeof options.config !== 'object') {
|
|
|
- options.config = {};
|
|
|
- }
|
|
|
- if (typeof options.catchError === 'undefined') {
|
|
|
- // Catch errors by default in web workers, do not catch errors by default in other contexts
|
|
|
- options.catchError = isWebWorker;
|
|
|
- }
|
|
|
- if (typeof options.urlArgs !== 'string') {
|
|
|
- options.urlArgs = '';
|
|
|
- }
|
|
|
- if (typeof options.onError !== 'function') {
|
|
|
- options.onError = defaultOnError;
|
|
|
- }
|
|
|
- if (typeof options.ignoreDuplicateModules !== 'object' || !Array.isArray(options.ignoreDuplicateModules)) {
|
|
|
- options.ignoreDuplicateModules = [];
|
|
|
- }
|
|
|
- if (options.baseUrl.length > 0) {
|
|
|
- if (!AMDLoader.Utilities.endsWith(options.baseUrl, '/')) {
|
|
|
- options.baseUrl += '/';
|
|
|
- }
|
|
|
- }
|
|
|
- if (!Array.isArray(options.nodeModules)) {
|
|
|
- options.nodeModules = [];
|
|
|
- }
|
|
|
- if (typeof options.nodeCachedDataWriteDelay !== 'number' || options.nodeCachedDataWriteDelay < 0) {
|
|
|
- options.nodeCachedDataWriteDelay = 1000 * 7;
|
|
|
- }
|
|
|
- if (typeof options.onNodeCachedData !== 'function') {
|
|
|
- options.onNodeCachedData = function (err, data) {
|
|
|
- if (!err) {
|
|
|
- // ignore
|
|
|
- }
|
|
|
- else if (err.errorCode === 'cachedDataRejected') {
|
|
|
- console.warn('Rejected cached data from file: ' + err.path);
|
|
|
- }
|
|
|
- else if (err.errorCode === 'unlink' || err.errorCode === 'writeFile') {
|
|
|
- console.error('Problems writing cached data file: ' + err.path);
|
|
|
- console.error(err.detail);
|
|
|
- }
|
|
|
- else {
|
|
|
- console.error(err);
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- return options;
|
|
|
- };
|
|
|
- ConfigurationOptionsUtil.mergeConfigurationOptions = function (isWebWorker, overwrite, base) {
|
|
|
- if (overwrite === void 0) { overwrite = null; }
|
|
|
- if (base === void 0) { base = null; }
|
|
|
- var result = AMDLoader.Utilities.recursiveClone(base || {});
|
|
|
- // Merge known properties and overwrite the unknown ones
|
|
|
- AMDLoader.Utilities.forEachProperty(overwrite, function (key, value) {
|
|
|
- if (key === 'ignoreDuplicateModules' && typeof result.ignoreDuplicateModules !== 'undefined') {
|
|
|
- result.ignoreDuplicateModules = result.ignoreDuplicateModules.concat(value);
|
|
|
- }
|
|
|
- else if (key === 'paths' && typeof result.paths !== 'undefined') {
|
|
|
- AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.paths[key2] = value2; });
|
|
|
- }
|
|
|
- else if (key === 'config' && typeof result.config !== 'undefined') {
|
|
|
- AMDLoader.Utilities.forEachProperty(value, function (key2, value2) { return result.config[key2] = value2; });
|
|
|
- }
|
|
|
- else {
|
|
|
- result[key] = AMDLoader.Utilities.recursiveClone(value);
|
|
|
- }
|
|
|
- });
|
|
|
- return ConfigurationOptionsUtil.validateConfigurationOptions(isWebWorker, result);
|
|
|
- };
|
|
|
- return ConfigurationOptionsUtil;
|
|
|
- }());
|
|
|
- AMDLoader.ConfigurationOptionsUtil = ConfigurationOptionsUtil;
|
|
|
- var Configuration = (function () {
|
|
|
- function Configuration(env, options) {
|
|
|
- this._env = env;
|
|
|
- this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(this._env.isWebWorker, options);
|
|
|
- this._createIgnoreDuplicateModulesMap();
|
|
|
- this._createNodeModulesMap();
|
|
|
- this._createSortedPathsRules();
|
|
|
- if (this.options.baseUrl === '') {
|
|
|
- if (this._env.isNode && this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename) {
|
|
|
- var nodeMain = this.options.nodeRequire.main.filename;
|
|
|
- var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\'));
|
|
|
- this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);
|
|
|
- }
|
|
|
- if (this._env.isNode && this.options.nodeMain) {
|
|
|
- var nodeMain = this.options.nodeMain;
|
|
|
- var dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\'));
|
|
|
- this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- Configuration.prototype._createIgnoreDuplicateModulesMap = function () {
|
|
|
- // Build a map out of the ignoreDuplicateModules array
|
|
|
- this.ignoreDuplicateModulesMap = {};
|
|
|
- for (var i = 0; i < this.options.ignoreDuplicateModules.length; i++) {
|
|
|
- this.ignoreDuplicateModulesMap[this.options.ignoreDuplicateModules[i]] = true;
|
|
|
- }
|
|
|
- };
|
|
|
- Configuration.prototype._createNodeModulesMap = function () {
|
|
|
- // Build a map out of nodeModules array
|
|
|
- this.nodeModulesMap = Object.create(null);
|
|
|
- for (var _i = 0, _a = this.options.nodeModules; _i < _a.length; _i++) {
|
|
|
- var nodeModule = _a[_i];
|
|
|
- this.nodeModulesMap[nodeModule] = true;
|
|
|
- }
|
|
|
- };
|
|
|
- Configuration.prototype._createSortedPathsRules = function () {
|
|
|
- var _this = this;
|
|
|
- // Create an array our of the paths rules, sorted descending by length to
|
|
|
- // result in a more specific -> less specific order
|
|
|
- this.sortedPathsRules = [];
|
|
|
- AMDLoader.Utilities.forEachProperty(this.options.paths, function (from, to) {
|
|
|
- if (!Array.isArray(to)) {
|
|
|
- _this.sortedPathsRules.push({
|
|
|
- from: from,
|
|
|
- to: [to]
|
|
|
- });
|
|
|
- }
|
|
|
- else {
|
|
|
- _this.sortedPathsRules.push({
|
|
|
- from: from,
|
|
|
- to: to
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- this.sortedPathsRules.sort(function (a, b) {
|
|
|
- return b.from.length - a.from.length;
|
|
|
- });
|
|
|
- };
|
|
|
- /**
|
|
|
- * Clone current configuration and overwrite options selectively.
|
|
|
- * @param options The selective options to overwrite with.
|
|
|
- * @result A new configuration
|
|
|
- */
|
|
|
- Configuration.prototype.cloneAndMerge = function (options) {
|
|
|
- return new Configuration(this._env, ConfigurationOptionsUtil.mergeConfigurationOptions(this._env.isWebWorker, options, this.options));
|
|
|
- };
|
|
|
- /**
|
|
|
- * Get current options bag. Useful for passing it forward to plugins.
|
|
|
- */
|
|
|
- Configuration.prototype.getOptionsLiteral = function () {
|
|
|
- return this.options;
|
|
|
- };
|
|
|
- Configuration.prototype._applyPaths = function (moduleId) {
|
|
|
- var pathRule;
|
|
|
- for (var i = 0, len = this.sortedPathsRules.length; i < len; i++) {
|
|
|
- pathRule = this.sortedPathsRules[i];
|
|
|
- if (AMDLoader.Utilities.startsWith(moduleId, pathRule.from)) {
|
|
|
- var result = [];
|
|
|
- for (var j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {
|
|
|
- result.push(pathRule.to[j] + moduleId.substr(pathRule.from.length));
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- }
|
|
|
- return [moduleId];
|
|
|
- };
|
|
|
- Configuration.prototype._addUrlArgsToUrl = function (url) {
|
|
|
- if (AMDLoader.Utilities.containsQueryString(url)) {
|
|
|
- return url + '&' + this.options.urlArgs;
|
|
|
- }
|
|
|
- else {
|
|
|
- return url + '?' + this.options.urlArgs;
|
|
|
- }
|
|
|
- };
|
|
|
- Configuration.prototype._addUrlArgsIfNecessaryToUrl = function (url) {
|
|
|
- if (this.options.urlArgs) {
|
|
|
- return this._addUrlArgsToUrl(url);
|
|
|
- }
|
|
|
- return url;
|
|
|
- };
|
|
|
- Configuration.prototype._addUrlArgsIfNecessaryToUrls = function (urls) {
|
|
|
- if (this.options.urlArgs) {
|
|
|
- for (var i = 0, len = urls.length; i < len; i++) {
|
|
|
- urls[i] = this._addUrlArgsToUrl(urls[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- return urls;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Transform a module id to a location. Appends .js to module ids
|
|
|
- */
|
|
|
- Configuration.prototype.moduleIdToPaths = function (moduleId) {
|
|
|
- if (this.nodeModulesMap[moduleId] === true) {
|
|
|
- // This is a node module...
|
|
|
- if (this.isBuild()) {
|
|
|
- // ...and we are at build time, drop it
|
|
|
- return ['empty:'];
|
|
|
- }
|
|
|
- else {
|
|
|
- // ...and at runtime we create a `shortcut`-path
|
|
|
- return ['node|' + moduleId];
|
|
|
- }
|
|
|
- }
|
|
|
- var result = moduleId;
|
|
|
- var results;
|
|
|
- if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.isAbsolutePath(result)) {
|
|
|
- results = this._applyPaths(result);
|
|
|
- for (var i = 0, len = results.length; i < len; i++) {
|
|
|
- if (this.isBuild() && results[i] === 'empty:') {
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (!AMDLoader.Utilities.isAbsolutePath(results[i])) {
|
|
|
- results[i] = this.options.baseUrl + results[i];
|
|
|
- }
|
|
|
- if (!AMDLoader.Utilities.endsWith(results[i], '.js') && !AMDLoader.Utilities.containsQueryString(results[i])) {
|
|
|
- results[i] = results[i] + '.js';
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- if (!AMDLoader.Utilities.endsWith(result, '.js') && !AMDLoader.Utilities.containsQueryString(result)) {
|
|
|
- result = result + '.js';
|
|
|
- }
|
|
|
- results = [result];
|
|
|
- }
|
|
|
- return this._addUrlArgsIfNecessaryToUrls(results);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Transform a module id or url to a location.
|
|
|
- */
|
|
|
- Configuration.prototype.requireToUrl = function (url) {
|
|
|
- var result = url;
|
|
|
- if (!AMDLoader.Utilities.isAbsolutePath(result)) {
|
|
|
- result = this._applyPaths(result)[0];
|
|
|
- if (!AMDLoader.Utilities.isAbsolutePath(result)) {
|
|
|
- result = this.options.baseUrl + result;
|
|
|
- }
|
|
|
- }
|
|
|
- return this._addUrlArgsIfNecessaryToUrl(result);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Flag to indicate if current execution is as part of a build.
|
|
|
- */
|
|
|
- Configuration.prototype.isBuild = function () {
|
|
|
- return this.options.isBuild;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if module `moduleId` is expected to be defined multiple times
|
|
|
- */
|
|
|
- Configuration.prototype.isDuplicateMessageIgnoredFor = function (moduleId) {
|
|
|
- return this.ignoreDuplicateModulesMap.hasOwnProperty(moduleId);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Get the configuration settings for the provided module id
|
|
|
- */
|
|
|
- Configuration.prototype.getConfigForModule = function (moduleId) {
|
|
|
- if (this.options.config) {
|
|
|
- return this.options.config[moduleId];
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * Should errors be caught when executing module factories?
|
|
|
- */
|
|
|
- Configuration.prototype.shouldCatchError = function () {
|
|
|
- return this.options.catchError;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Should statistics be recorded?
|
|
|
- */
|
|
|
- Configuration.prototype.shouldRecordStats = function () {
|
|
|
- return this.options.recordStats;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Forward an error to the error handler.
|
|
|
- */
|
|
|
- Configuration.prototype.onError = function (err) {
|
|
|
- this.options.onError(err);
|
|
|
- };
|
|
|
- return Configuration;
|
|
|
- }());
|
|
|
- AMDLoader.Configuration = Configuration;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- /**
|
|
|
- * Load `scriptSrc` only once (avoid multiple <script> tags)
|
|
|
- */
|
|
|
- var OnlyOnceScriptLoader = (function () {
|
|
|
- function OnlyOnceScriptLoader(actualScriptLoader) {
|
|
|
- this.actualScriptLoader = actualScriptLoader;
|
|
|
- this.callbackMap = {};
|
|
|
- }
|
|
|
- OnlyOnceScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
|
|
|
- var _this = this;
|
|
|
- var scriptCallbacks = {
|
|
|
- callback: callback,
|
|
|
- errorback: errorback
|
|
|
- };
|
|
|
- if (this.callbackMap.hasOwnProperty(scriptSrc)) {
|
|
|
- this.callbackMap[scriptSrc].push(scriptCallbacks);
|
|
|
- return;
|
|
|
- }
|
|
|
- this.callbackMap[scriptSrc] = [scriptCallbacks];
|
|
|
- this.actualScriptLoader.load(moduleManager, scriptSrc, function () { return _this.triggerCallback(scriptSrc); }, function (err) { return _this.triggerErrorback(scriptSrc, err); });
|
|
|
- };
|
|
|
- OnlyOnceScriptLoader.prototype.triggerCallback = function (scriptSrc) {
|
|
|
- var scriptCallbacks = this.callbackMap[scriptSrc];
|
|
|
- delete this.callbackMap[scriptSrc];
|
|
|
- for (var i = 0; i < scriptCallbacks.length; i++) {
|
|
|
- scriptCallbacks[i].callback();
|
|
|
- }
|
|
|
- };
|
|
|
- OnlyOnceScriptLoader.prototype.triggerErrorback = function (scriptSrc, err) {
|
|
|
- var scriptCallbacks = this.callbackMap[scriptSrc];
|
|
|
- delete this.callbackMap[scriptSrc];
|
|
|
- for (var i = 0; i < scriptCallbacks.length; i++) {
|
|
|
- scriptCallbacks[i].errorback(err);
|
|
|
- }
|
|
|
- };
|
|
|
- return OnlyOnceScriptLoader;
|
|
|
- }());
|
|
|
- var BrowserScriptLoader = (function () {
|
|
|
- function BrowserScriptLoader() {
|
|
|
- }
|
|
|
- /**
|
|
|
- * Attach load / error listeners to a script element and remove them when either one has fired.
|
|
|
- * Implemented for browssers supporting HTML5 standard 'load' and 'error' events.
|
|
|
- */
|
|
|
- BrowserScriptLoader.prototype.attachListeners = function (script, callback, errorback) {
|
|
|
- var unbind = function () {
|
|
|
- script.removeEventListener('load', loadEventListener);
|
|
|
- script.removeEventListener('error', errorEventListener);
|
|
|
- };
|
|
|
- var loadEventListener = function (e) {
|
|
|
- unbind();
|
|
|
- callback();
|
|
|
- };
|
|
|
- var errorEventListener = function (e) {
|
|
|
- unbind();
|
|
|
- errorback(e);
|
|
|
- };
|
|
|
- script.addEventListener('load', loadEventListener);
|
|
|
- script.addEventListener('error', errorEventListener);
|
|
|
- };
|
|
|
- BrowserScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
|
|
|
- var script = document.createElement('script');
|
|
|
- script.setAttribute('async', 'async');
|
|
|
- script.setAttribute('type', 'text/javascript');
|
|
|
- this.attachListeners(script, callback, errorback);
|
|
|
- script.setAttribute('src', scriptSrc);
|
|
|
- document.getElementsByTagName('head')[0].appendChild(script);
|
|
|
- };
|
|
|
- return BrowserScriptLoader;
|
|
|
- }());
|
|
|
- var WorkerScriptLoader = (function () {
|
|
|
- function WorkerScriptLoader() {
|
|
|
- }
|
|
|
- WorkerScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
|
|
|
- try {
|
|
|
- importScripts(scriptSrc);
|
|
|
- callback();
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- errorback(e);
|
|
|
- }
|
|
|
- };
|
|
|
- return WorkerScriptLoader;
|
|
|
- }());
|
|
|
- var NodeScriptLoader = (function () {
|
|
|
- function NodeScriptLoader(env) {
|
|
|
- this._env = env;
|
|
|
- this._didInitialize = false;
|
|
|
- this._didPatchNodeRequire = false;
|
|
|
- }
|
|
|
- NodeScriptLoader.prototype._init = function (nodeRequire) {
|
|
|
- if (this._didInitialize) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._didInitialize = true;
|
|
|
- // capture node modules
|
|
|
- this._fs = nodeRequire('fs');
|
|
|
- this._vm = nodeRequire('vm');
|
|
|
- this._path = nodeRequire('path');
|
|
|
- this._crypto = nodeRequire('crypto');
|
|
|
- // js-flags have an impact on cached data
|
|
|
- this._jsflags = '';
|
|
|
- for (var _i = 0, _a = process.argv; _i < _a.length; _i++) {
|
|
|
- var arg = _a[_i];
|
|
|
- if (arg.indexOf('--js-flags=') === 0) {
|
|
|
- this._jsflags = arg;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- // patch require-function of nodejs such that we can manually create a script
|
|
|
- // from cached data. this is done by overriding the `Module._compile` function
|
|
|
- NodeScriptLoader.prototype._initNodeRequire = function (nodeRequire, moduleManager) {
|
|
|
- var nodeCachedDataDir = moduleManager.getConfig().getOptionsLiteral().nodeCachedDataDir;
|
|
|
- if (!nodeCachedDataDir || this._didPatchNodeRequire) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._didPatchNodeRequire = true;
|
|
|
- var that = this;
|
|
|
- var Module = nodeRequire('module');
|
|
|
- function makeRequireFunction(mod) {
|
|
|
- var Module = mod.constructor;
|
|
|
- var require = function require(path) {
|
|
|
- try {
|
|
|
- return mod.require(path);
|
|
|
- }
|
|
|
- finally {
|
|
|
- // nothing
|
|
|
- }
|
|
|
- };
|
|
|
- require.resolve = function resolve(request) {
|
|
|
- return Module._resolveFilename(request, mod);
|
|
|
- };
|
|
|
- require.main = process.mainModule;
|
|
|
- require.extensions = Module._extensions;
|
|
|
- require.cache = Module._cache;
|
|
|
- return require;
|
|
|
- }
|
|
|
- Module.prototype._compile = function (content, filename) {
|
|
|
- // remove shebang
|
|
|
- content = content.replace(/^#!.*/, '');
|
|
|
- // create wrapper function
|
|
|
- var wrapper = Module.wrap(content);
|
|
|
- var cachedDataPath = that._getCachedDataPath(nodeCachedDataDir, filename);
|
|
|
- var options = { filename: filename };
|
|
|
- try {
|
|
|
- options.cachedData = that._fs.readFileSync(cachedDataPath);
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- options.produceCachedData = true;
|
|
|
- }
|
|
|
- var script = new that._vm.Script(wrapper, options);
|
|
|
- var compileWrapper = script.runInThisContext(options);
|
|
|
- var dirname = that._path.dirname(filename);
|
|
|
- var require = makeRequireFunction(this);
|
|
|
- var args = [this.exports, require, this, filename, dirname, process, AMDLoader.global, Buffer];
|
|
|
- var result = compileWrapper.apply(this.exports, args);
|
|
|
- that._processCachedData(moduleManager, script, cachedDataPath);
|
|
|
- return result;
|
|
|
- };
|
|
|
- };
|
|
|
- NodeScriptLoader.prototype.load = function (moduleManager, scriptSrc, callback, errorback) {
|
|
|
- var _this = this;
|
|
|
- var opts = moduleManager.getConfig().getOptionsLiteral();
|
|
|
- var nodeRequire = (opts.nodeRequire || AMDLoader.global.nodeRequire);
|
|
|
- var nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });
|
|
|
- this._init(nodeRequire);
|
|
|
- this._initNodeRequire(nodeRequire, moduleManager);
|
|
|
- var recorder = moduleManager.getRecorder();
|
|
|
- if (/^node\|/.test(scriptSrc)) {
|
|
|
- var pieces = scriptSrc.split('|');
|
|
|
- var moduleExports_1 = null;
|
|
|
- try {
|
|
|
- moduleExports_1 = nodeRequire(pieces[1]);
|
|
|
- }
|
|
|
- catch (err) {
|
|
|
- errorback(err);
|
|
|
- return;
|
|
|
- }
|
|
|
- moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports_1; });
|
|
|
- callback();
|
|
|
- }
|
|
|
- else {
|
|
|
- scriptSrc = AMDLoader.Utilities.fileUriToFilePath(this._env.isWindows, scriptSrc);
|
|
|
- this._fs.readFile(scriptSrc, { encoding: 'utf8' }, function (err, data) {
|
|
|
- if (err) {
|
|
|
- errorback(err);
|
|
|
- return;
|
|
|
- }
|
|
|
- var normalizedScriptSrc = _this._path.normalize(scriptSrc);
|
|
|
- var vmScriptSrc = normalizedScriptSrc;
|
|
|
- // Make the script src friendly towards electron
|
|
|
- if (_this._env.isElectronRenderer) {
|
|
|
- var driveLetterMatch = vmScriptSrc.match(/^([a-z])\:(.*)/i);
|
|
|
- if (driveLetterMatch) {
|
|
|
- // windows
|
|
|
- vmScriptSrc = "file:///" + (driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\/g, '/');
|
|
|
- }
|
|
|
- else {
|
|
|
- // nix
|
|
|
- vmScriptSrc = "file://" + vmScriptSrc;
|
|
|
- }
|
|
|
- }
|
|
|
- var contents, prefix = '(function (require, define, __filename, __dirname) { ', suffix = '\n});';
|
|
|
- if (data.charCodeAt(0) === NodeScriptLoader._BOM) {
|
|
|
- contents = prefix + data.substring(1) + suffix;
|
|
|
- }
|
|
|
- else {
|
|
|
- contents = prefix + data + suffix;
|
|
|
- }
|
|
|
- contents = nodeInstrumenter(contents, normalizedScriptSrc);
|
|
|
- if (!opts.nodeCachedDataDir) {
|
|
|
- _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, { filename: vmScriptSrc }, recorder);
|
|
|
- callback();
|
|
|
- }
|
|
|
- else {
|
|
|
- var cachedDataPath_1 = _this._getCachedDataPath(opts.nodeCachedDataDir, scriptSrc);
|
|
|
- _this._fs.readFile(cachedDataPath_1, function (err, cachedData) {
|
|
|
- // create script options
|
|
|
- var options = {
|
|
|
- filename: vmScriptSrc,
|
|
|
- produceCachedData: typeof cachedData === 'undefined',
|
|
|
- cachedData: cachedData
|
|
|
- };
|
|
|
- var script = _this._loadAndEvalScript(moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder);
|
|
|
- callback();
|
|
|
- _this._processCachedData(moduleManager, script, cachedDataPath_1);
|
|
|
- });
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- };
|
|
|
- NodeScriptLoader.prototype._loadAndEvalScript = function (moduleManager, scriptSrc, vmScriptSrc, contents, options, recorder) {
|
|
|
- // create script, run script
|
|
|
- recorder.record(AMDLoader.LoaderEventType.NodeBeginEvaluatingScript, scriptSrc);
|
|
|
- var script = new this._vm.Script(contents, options);
|
|
|
- var r = script.runInThisContext(options);
|
|
|
- r.call(AMDLoader.global, moduleManager.getGlobalAMDRequireFunc(), moduleManager.getGlobalAMDDefineFunc(), vmScriptSrc, this._path.dirname(scriptSrc));
|
|
|
- // signal done
|
|
|
- recorder.record(AMDLoader.LoaderEventType.NodeEndEvaluatingScript, scriptSrc);
|
|
|
- return script;
|
|
|
- };
|
|
|
- NodeScriptLoader.prototype._getCachedDataPath = function (basedir, filename) {
|
|
|
- var hash = this._crypto.createHash('md5').update(filename, 'utf8').update(this._jsflags, 'utf8').digest('hex');
|
|
|
- var basename = this._path.basename(filename).replace(/\.js$/, '');
|
|
|
- return this._path.join(basedir, basename + "-" + hash + ".code");
|
|
|
- };
|
|
|
- NodeScriptLoader.prototype._processCachedData = function (moduleManager, script, cachedDataPath) {
|
|
|
- var _this = this;
|
|
|
- if (script.cachedDataRejected) {
|
|
|
- // data rejected => delete cache file
|
|
|
- moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
|
|
|
- errorCode: 'cachedDataRejected',
|
|
|
- path: cachedDataPath
|
|
|
- });
|
|
|
- NodeScriptLoader._runSoon(function () { return _this._fs.unlink(cachedDataPath, function (err) {
|
|
|
- if (err) {
|
|
|
- moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
|
|
|
- errorCode: 'unlink',
|
|
|
- path: cachedDataPath,
|
|
|
- detail: err
|
|
|
- });
|
|
|
- }
|
|
|
- }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
|
|
|
- }
|
|
|
- else if (script.cachedDataProduced) {
|
|
|
- // data produced => tell outside world
|
|
|
- moduleManager.getConfig().getOptionsLiteral().onNodeCachedData(undefined, {
|
|
|
- path: cachedDataPath,
|
|
|
- length: script.cachedData.length
|
|
|
- });
|
|
|
- // data produced => write cache file
|
|
|
- NodeScriptLoader._runSoon(function () { return _this._fs.writeFile(cachedDataPath, script.cachedData, function (err) {
|
|
|
- if (err) {
|
|
|
- moduleManager.getConfig().getOptionsLiteral().onNodeCachedData({
|
|
|
- errorCode: 'writeFile',
|
|
|
- path: cachedDataPath,
|
|
|
- detail: err
|
|
|
- });
|
|
|
- }
|
|
|
- }); }, moduleManager.getConfig().getOptionsLiteral().nodeCachedDataWriteDelay);
|
|
|
- }
|
|
|
- };
|
|
|
- NodeScriptLoader._runSoon = function (callback, minTimeout) {
|
|
|
- var timeout = minTimeout + Math.ceil(Math.random() * minTimeout);
|
|
|
- setTimeout(callback, timeout);
|
|
|
- };
|
|
|
- return NodeScriptLoader;
|
|
|
- }());
|
|
|
- NodeScriptLoader._BOM = 0xFEFF;
|
|
|
- function createScriptLoader(env) {
|
|
|
- return new OnlyOnceScriptLoader(env.isWebWorker ?
|
|
|
- new WorkerScriptLoader()
|
|
|
- : env.isNode ?
|
|
|
- new NodeScriptLoader(env)
|
|
|
- : new BrowserScriptLoader());
|
|
|
- }
|
|
|
- AMDLoader.createScriptLoader = createScriptLoader;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- // ------------------------------------------------------------------------
|
|
|
- // ModuleIdResolver
|
|
|
- var ModuleIdResolver = (function () {
|
|
|
- function ModuleIdResolver(fromModuleId) {
|
|
|
- var lastSlash = fromModuleId.lastIndexOf('/');
|
|
|
- if (lastSlash !== -1) {
|
|
|
- this.fromModulePath = fromModuleId.substr(0, lastSlash + 1);
|
|
|
- }
|
|
|
- else {
|
|
|
- this.fromModulePath = '';
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Normalize 'a/../name' to 'name', etc.
|
|
|
- */
|
|
|
- ModuleIdResolver._normalizeModuleId = function (moduleId) {
|
|
|
- var r = moduleId, pattern;
|
|
|
- // replace /./ => /
|
|
|
- pattern = /\/\.\//;
|
|
|
- while (pattern.test(r)) {
|
|
|
- r = r.replace(pattern, '/');
|
|
|
- }
|
|
|
- // replace ^./ => nothing
|
|
|
- r = r.replace(/^\.\//g, '');
|
|
|
- // replace /aa/../ => / (BUT IGNORE /../../)
|
|
|
- pattern = /\/(([^\/])|([^\/][^\/\.])|([^\/\.][^\/])|([^\/][^\/][^\/]+))\/\.\.\//;
|
|
|
- while (pattern.test(r)) {
|
|
|
- r = r.replace(pattern, '/');
|
|
|
- }
|
|
|
- // replace ^aa/../ => nothing (BUT IGNORE ../../)
|
|
|
- r = r.replace(/^(([^\/])|([^\/][^\/\.])|([^\/\.][^\/])|([^\/][^\/][^\/]+))\/\.\.\//, '');
|
|
|
- return r;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Resolve relative module ids
|
|
|
- */
|
|
|
- ModuleIdResolver.prototype.resolveModule = function (moduleId) {
|
|
|
- var result = moduleId;
|
|
|
- if (!AMDLoader.Utilities.isAbsolutePath(result)) {
|
|
|
- if (AMDLoader.Utilities.startsWith(result, './') || AMDLoader.Utilities.startsWith(result, '../')) {
|
|
|
- result = ModuleIdResolver._normalizeModuleId(this.fromModulePath + result);
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- return ModuleIdResolver;
|
|
|
- }());
|
|
|
- ModuleIdResolver.ROOT = new ModuleIdResolver('');
|
|
|
- AMDLoader.ModuleIdResolver = ModuleIdResolver;
|
|
|
- // ------------------------------------------------------------------------
|
|
|
- // Module
|
|
|
- var Module = (function () {
|
|
|
- function Module(id, strId, dependencies, callback, errorback, moduleIdResolver) {
|
|
|
- this.id = id;
|
|
|
- this.strId = strId;
|
|
|
- this.dependencies = dependencies;
|
|
|
- this._callback = callback;
|
|
|
- this._errorback = errorback;
|
|
|
- this.moduleIdResolver = moduleIdResolver;
|
|
|
- this.exports = {};
|
|
|
- this.exportsPassedIn = false;
|
|
|
- this.unresolvedDependenciesCount = this.dependencies.length;
|
|
|
- this._isComplete = false;
|
|
|
- }
|
|
|
- Module._safeInvokeFunction = function (callback, args) {
|
|
|
- try {
|
|
|
- return {
|
|
|
- returnedValue: callback.apply(AMDLoader.global, args),
|
|
|
- producedError: null
|
|
|
- };
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- return {
|
|
|
- returnedValue: null,
|
|
|
- producedError: e
|
|
|
- };
|
|
|
- }
|
|
|
- };
|
|
|
- Module._invokeFactory = function (config, strModuleId, callback, dependenciesValues) {
|
|
|
- if (config.isBuild() && !AMDLoader.Utilities.isAnonymousModule(strModuleId)) {
|
|
|
- return {
|
|
|
- returnedValue: null,
|
|
|
- producedError: null
|
|
|
- };
|
|
|
- }
|
|
|
- if (config.shouldCatchError()) {
|
|
|
- return this._safeInvokeFunction(callback, dependenciesValues);
|
|
|
- }
|
|
|
- return {
|
|
|
- returnedValue: callback.apply(AMDLoader.global, dependenciesValues),
|
|
|
- producedError: null
|
|
|
- };
|
|
|
- };
|
|
|
- Module.prototype.complete = function (recorder, config, dependenciesValues) {
|
|
|
- this._isComplete = true;
|
|
|
- var producedError = null;
|
|
|
- if (this._callback) {
|
|
|
- if (typeof this._callback === 'function') {
|
|
|
- recorder.record(AMDLoader.LoaderEventType.BeginInvokeFactory, this.strId);
|
|
|
- var r = Module._invokeFactory(config, this.strId, this._callback, dependenciesValues);
|
|
|
- producedError = r.producedError;
|
|
|
- recorder.record(AMDLoader.LoaderEventType.EndInvokeFactory, this.strId);
|
|
|
- if (!producedError && typeof r.returnedValue !== 'undefined' && (!this.exportsPassedIn || AMDLoader.Utilities.isEmpty(this.exports))) {
|
|
|
- this.exports = r.returnedValue;
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- this.exports = this._callback;
|
|
|
- }
|
|
|
- }
|
|
|
- if (producedError) {
|
|
|
- config.onError({
|
|
|
- errorCode: 'factory',
|
|
|
- moduleId: this.strId,
|
|
|
- detail: producedError
|
|
|
- });
|
|
|
- }
|
|
|
- this.dependencies = null;
|
|
|
- this._callback = null;
|
|
|
- this._errorback = null;
|
|
|
- this.moduleIdResolver = null;
|
|
|
- };
|
|
|
- /**
|
|
|
- * One of the direct dependencies or a transitive dependency has failed to load.
|
|
|
- */
|
|
|
- Module.prototype.onDependencyError = function (err) {
|
|
|
- if (this._errorback) {
|
|
|
- this._errorback(err);
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Is the current module complete?
|
|
|
- */
|
|
|
- Module.prototype.isComplete = function () {
|
|
|
- return this._isComplete;
|
|
|
- };
|
|
|
- return Module;
|
|
|
- }());
|
|
|
- AMDLoader.Module = Module;
|
|
|
- var ModuleIdProvider = (function () {
|
|
|
- function ModuleIdProvider() {
|
|
|
- this._nextId = 0;
|
|
|
- this._strModuleIdToIntModuleId = new Map();
|
|
|
- this._intModuleIdToStrModuleId = [];
|
|
|
- // Ensure values 0, 1, 2 are assigned accordingly with ModuleId
|
|
|
- this.getModuleId('exports');
|
|
|
- this.getModuleId('module');
|
|
|
- this.getModuleId('require');
|
|
|
- }
|
|
|
- ModuleIdProvider.prototype.getMaxModuleId = function () {
|
|
|
- return this._nextId;
|
|
|
- };
|
|
|
- ModuleIdProvider.prototype.getModuleId = function (strModuleId) {
|
|
|
- var id = this._strModuleIdToIntModuleId.get(strModuleId);
|
|
|
- if (typeof id === 'undefined') {
|
|
|
- id = this._nextId++;
|
|
|
- this._strModuleIdToIntModuleId.set(strModuleId, id);
|
|
|
- this._intModuleIdToStrModuleId[id] = strModuleId;
|
|
|
- }
|
|
|
- return id;
|
|
|
- };
|
|
|
- ModuleIdProvider.prototype.getStrModuleId = function (moduleId) {
|
|
|
- return this._intModuleIdToStrModuleId[moduleId];
|
|
|
- };
|
|
|
- return ModuleIdProvider;
|
|
|
- }());
|
|
|
- var RegularDependency = (function () {
|
|
|
- function RegularDependency(id) {
|
|
|
- this.id = id;
|
|
|
- }
|
|
|
- return RegularDependency;
|
|
|
- }());
|
|
|
- RegularDependency.EXPORTS = new RegularDependency(0 /* EXPORTS */);
|
|
|
- RegularDependency.MODULE = new RegularDependency(1 /* MODULE */);
|
|
|
- RegularDependency.REQUIRE = new RegularDependency(2 /* REQUIRE */);
|
|
|
- AMDLoader.RegularDependency = RegularDependency;
|
|
|
- var PluginDependency = (function () {
|
|
|
- function PluginDependency(id, pluginId, pluginParam) {
|
|
|
- this.id = id;
|
|
|
- this.pluginId = pluginId;
|
|
|
- this.pluginParam = pluginParam;
|
|
|
- }
|
|
|
- return PluginDependency;
|
|
|
- }());
|
|
|
- AMDLoader.PluginDependency = PluginDependency;
|
|
|
- var ModuleManager = (function () {
|
|
|
- function ModuleManager(env, scriptLoader, defineFunc, requireFunc, loaderAvailableTimestamp) {
|
|
|
- if (loaderAvailableTimestamp === void 0) { loaderAvailableTimestamp = 0; }
|
|
|
- this._env = env;
|
|
|
- this._scriptLoader = scriptLoader;
|
|
|
- this._loaderAvailableTimestamp = loaderAvailableTimestamp;
|
|
|
- this._defineFunc = defineFunc;
|
|
|
- this._requireFunc = requireFunc;
|
|
|
- this._moduleIdProvider = new ModuleIdProvider();
|
|
|
- this._config = new AMDLoader.Configuration(this._env);
|
|
|
- this._modules2 = [];
|
|
|
- this._knownModules2 = [];
|
|
|
- this._inverseDependencies2 = [];
|
|
|
- this._inversePluginDependencies2 = new Map();
|
|
|
- this._currentAnnonymousDefineCall = null;
|
|
|
- this._recorder = null;
|
|
|
- this._buildInfoPath = [];
|
|
|
- this._buildInfoDefineStack = [];
|
|
|
- this._buildInfoDependencies = [];
|
|
|
- }
|
|
|
- ModuleManager.prototype.reset = function () {
|
|
|
- return new ModuleManager(this._env, this._scriptLoader, this._defineFunc, this._requireFunc, this._loaderAvailableTimestamp);
|
|
|
- };
|
|
|
- ModuleManager.prototype.getGlobalAMDDefineFunc = function () {
|
|
|
- return this._defineFunc;
|
|
|
- };
|
|
|
- ModuleManager.prototype.getGlobalAMDRequireFunc = function () {
|
|
|
- return this._requireFunc;
|
|
|
- };
|
|
|
- ModuleManager._findRelevantLocationInStack = function (needle, stack) {
|
|
|
- var normalize = function (str) { return str.replace(/\\/g, '/'); };
|
|
|
- var normalizedPath = normalize(needle);
|
|
|
- var stackPieces = stack.split(/\n/);
|
|
|
- for (var i = 0; i < stackPieces.length; i++) {
|
|
|
- var m = stackPieces[i].match(/(.*):(\d+):(\d+)\)?$/);
|
|
|
- if (m) {
|
|
|
- var stackPath = m[1];
|
|
|
- var stackLine = m[2];
|
|
|
- var stackColumn = m[3];
|
|
|
- var trimPathOffset = Math.max(stackPath.lastIndexOf(' ') + 1, stackPath.lastIndexOf('(') + 1);
|
|
|
- stackPath = stackPath.substr(trimPathOffset);
|
|
|
- stackPath = normalize(stackPath);
|
|
|
- if (stackPath === normalizedPath) {
|
|
|
- var r = {
|
|
|
- line: parseInt(stackLine, 10),
|
|
|
- col: parseInt(stackColumn, 10)
|
|
|
- };
|
|
|
- if (r.line === 1) {
|
|
|
- r.col -= '(function (require, define, __filename, __dirname) { '.length;
|
|
|
- }
|
|
|
- return r;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- throw new Error('Could not correlate define call site for needle ' + needle);
|
|
|
- };
|
|
|
- ModuleManager.prototype.getBuildInfo = function () {
|
|
|
- if (!this._config.isBuild()) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var result = [], resultLen = 0;
|
|
|
- for (var i = 0, len = this._modules2.length; i < len; i++) {
|
|
|
- var m = this._modules2[i];
|
|
|
- if (!m) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- var location_1 = this._buildInfoPath[m.id] || null;
|
|
|
- var defineStack = this._buildInfoDefineStack[m.id] || null;
|
|
|
- var dependencies = this._buildInfoDependencies[m.id];
|
|
|
- result[resultLen++] = {
|
|
|
- id: m.strId,
|
|
|
- path: location_1,
|
|
|
- defineLocation: (location_1 && defineStack ? ModuleManager._findRelevantLocationInStack(location_1, defineStack) : null),
|
|
|
- dependencies: dependencies,
|
|
|
- shim: null,
|
|
|
- exports: m.exports
|
|
|
- };
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- ModuleManager.prototype.getRecorder = function () {
|
|
|
- if (!this._recorder) {
|
|
|
- if (this._config.shouldRecordStats()) {
|
|
|
- this._recorder = new AMDLoader.LoaderEventRecorder(this._loaderAvailableTimestamp);
|
|
|
- }
|
|
|
- else {
|
|
|
- this._recorder = AMDLoader.NullLoaderEventRecorder.INSTANCE;
|
|
|
- }
|
|
|
- }
|
|
|
- return this._recorder;
|
|
|
- };
|
|
|
- ModuleManager.prototype.getLoaderEvents = function () {
|
|
|
- return this.getRecorder().getEvents();
|
|
|
- };
|
|
|
- /**
|
|
|
- * Defines an anonymous module (without an id). Its name will be resolved as we receive a callback from the scriptLoader.
|
|
|
- * @param dependecies @see defineModule
|
|
|
- * @param callback @see defineModule
|
|
|
- */
|
|
|
- ModuleManager.prototype.enqueueDefineAnonymousModule = function (dependencies, callback) {
|
|
|
- if (this._currentAnnonymousDefineCall !== null) {
|
|
|
- throw new Error('Can only have one anonymous define call per script file');
|
|
|
- }
|
|
|
- var stack = null;
|
|
|
- if (this._config.isBuild()) {
|
|
|
- stack = new Error('StackLocation').stack;
|
|
|
- }
|
|
|
- this._currentAnnonymousDefineCall = {
|
|
|
- stack: stack,
|
|
|
- dependencies: dependencies,
|
|
|
- callback: callback
|
|
|
- };
|
|
|
- };
|
|
|
- /**
|
|
|
- * Creates a module and stores it in _modules. The manager will immediately begin resolving its dependencies.
|
|
|
- * @param strModuleId An unique and absolute id of the module. This must not collide with another module's id
|
|
|
- * @param dependencies An array with the dependencies of the module. Special keys are: "require", "exports" and "module"
|
|
|
- * @param callback if callback is a function, it will be called with the resolved dependencies. if callback is an object, it will be considered as the exports of the module.
|
|
|
- */
|
|
|
- ModuleManager.prototype.defineModule = function (strModuleId, dependencies, callback, errorback, stack, moduleIdResolver) {
|
|
|
- var _this = this;
|
|
|
- if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(strModuleId); }
|
|
|
- var moduleId = this._moduleIdProvider.getModuleId(strModuleId);
|
|
|
- if (this._modules2[moduleId]) {
|
|
|
- if (!this._config.isDuplicateMessageIgnoredFor(strModuleId)) {
|
|
|
- console.warn('Duplicate definition of module \'' + strModuleId + '\'');
|
|
|
- }
|
|
|
- // Super important! Completely ignore duplicate module definition
|
|
|
- return;
|
|
|
- }
|
|
|
- var m = new Module(moduleId, strModuleId, this._normalizeDependencies(dependencies, moduleIdResolver), callback, errorback, moduleIdResolver);
|
|
|
- this._modules2[moduleId] = m;
|
|
|
- if (this._config.isBuild()) {
|
|
|
- this._buildInfoDefineStack[moduleId] = stack;
|
|
|
- this._buildInfoDependencies[moduleId] = m.dependencies.map(function (dep) { return _this._moduleIdProvider.getStrModuleId(dep.id); });
|
|
|
- }
|
|
|
- // Resolving of dependencies is immediate (not in a timeout). If there's a need to support a packer that concatenates in an
|
|
|
- // unordered manner, in order to finish processing the file, execute the following method in a timeout
|
|
|
- this._resolve(m);
|
|
|
- };
|
|
|
- ModuleManager.prototype._normalizeDependency = function (dependency, moduleIdResolver) {
|
|
|
- if (dependency === 'exports') {
|
|
|
- return RegularDependency.EXPORTS;
|
|
|
- }
|
|
|
- if (dependency === 'module') {
|
|
|
- return RegularDependency.MODULE;
|
|
|
- }
|
|
|
- if (dependency === 'require') {
|
|
|
- return RegularDependency.REQUIRE;
|
|
|
- }
|
|
|
- // Normalize dependency and then request it from the manager
|
|
|
- var bangIndex = dependency.indexOf('!');
|
|
|
- if (bangIndex >= 0) {
|
|
|
- var strPluginId = moduleIdResolver.resolveModule(dependency.substr(0, bangIndex));
|
|
|
- var pluginParam = moduleIdResolver.resolveModule(dependency.substr(bangIndex + 1));
|
|
|
- var dependencyId = this._moduleIdProvider.getModuleId(strPluginId + '!' + pluginParam);
|
|
|
- var pluginId = this._moduleIdProvider.getModuleId(strPluginId);
|
|
|
- return new PluginDependency(dependencyId, pluginId, pluginParam);
|
|
|
- }
|
|
|
- return new RegularDependency(this._moduleIdProvider.getModuleId(moduleIdResolver.resolveModule(dependency)));
|
|
|
- };
|
|
|
- ModuleManager.prototype._normalizeDependencies = function (dependencies, moduleIdResolver) {
|
|
|
- var result = [], resultLen = 0;
|
|
|
- for (var i = 0, len = dependencies.length; i < len; i++) {
|
|
|
- result[resultLen++] = this._normalizeDependency(dependencies[i], moduleIdResolver);
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- ModuleManager.prototype._relativeRequire = function (moduleIdResolver, dependencies, callback, errorback) {
|
|
|
- if (typeof dependencies === 'string') {
|
|
|
- return this.synchronousRequire(dependencies, moduleIdResolver);
|
|
|
- }
|
|
|
- this.defineModule(AMDLoader.Utilities.generateAnonymousModule(), dependencies, callback, errorback, null, moduleIdResolver);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Require synchronously a module by its absolute id. If the module is not loaded, an exception will be thrown.
|
|
|
- * @param id The unique and absolute id of the required module
|
|
|
- * @return The exports of module 'id'
|
|
|
- */
|
|
|
- ModuleManager.prototype.synchronousRequire = function (_strModuleId, moduleIdResolver) {
|
|
|
- if (moduleIdResolver === void 0) { moduleIdResolver = new ModuleIdResolver(_strModuleId); }
|
|
|
- var dependency = this._normalizeDependency(_strModuleId, moduleIdResolver);
|
|
|
- var m = this._modules2[dependency.id];
|
|
|
- if (!m) {
|
|
|
- throw new Error('Check dependency list! Synchronous require cannot resolve module \'' + _strModuleId + '\'. This is the first mention of this module!');
|
|
|
- }
|
|
|
- if (!m.isComplete()) {
|
|
|
- throw new Error('Check dependency list! Synchronous require cannot resolve module \'' + _strModuleId + '\'. This module has not been resolved completely yet.');
|
|
|
- }
|
|
|
- return m.exports;
|
|
|
- };
|
|
|
- ModuleManager.prototype.configure = function (params, shouldOverwrite) {
|
|
|
- var oldShouldRecordStats = this._config.shouldRecordStats();
|
|
|
- if (shouldOverwrite) {
|
|
|
- this._config = new AMDLoader.Configuration(this._env, params);
|
|
|
- }
|
|
|
- else {
|
|
|
- this._config = this._config.cloneAndMerge(params);
|
|
|
- }
|
|
|
- if (this._config.shouldRecordStats() && !oldShouldRecordStats) {
|
|
|
- this._recorder = null;
|
|
|
- }
|
|
|
- };
|
|
|
- ModuleManager.prototype.getConfig = function () {
|
|
|
- return this._config;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Callback from the scriptLoader when a module has been loaded.
|
|
|
- * This means its code is available and has been executed.
|
|
|
- */
|
|
|
- ModuleManager.prototype._onLoad = function (moduleId) {
|
|
|
- if (this._currentAnnonymousDefineCall !== null) {
|
|
|
- var defineCall = this._currentAnnonymousDefineCall;
|
|
|
- this._currentAnnonymousDefineCall = null;
|
|
|
- // Hit an anonymous define call
|
|
|
- this.defineModule(this._moduleIdProvider.getStrModuleId(moduleId), defineCall.dependencies, defineCall.callback, null, defineCall.stack);
|
|
|
- }
|
|
|
- };
|
|
|
- ModuleManager.prototype._createLoadError = function (moduleId, err) {
|
|
|
- var _this = this;
|
|
|
- var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
|
|
|
- var neededBy = (this._inverseDependencies2[moduleId] || []).map(function (intModuleId) { return _this._moduleIdProvider.getStrModuleId(intModuleId); });
|
|
|
- return {
|
|
|
- errorCode: 'load',
|
|
|
- moduleId: strModuleId,
|
|
|
- neededBy: neededBy,
|
|
|
- detail: err
|
|
|
- };
|
|
|
- };
|
|
|
- /**
|
|
|
- * Callback from the scriptLoader when a module hasn't been loaded.
|
|
|
- * This means that the script was not found (e.g. 404) or there was an error in the script.
|
|
|
- */
|
|
|
- ModuleManager.prototype._onLoadError = function (moduleId, err) {
|
|
|
- var error = this._createLoadError(moduleId, err);
|
|
|
- // Find any 'local' error handlers, walk the entire chain of inverse dependencies if necessary.
|
|
|
- var seenModuleId = [];
|
|
|
- for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
|
|
|
- seenModuleId[i] = false;
|
|
|
- }
|
|
|
- var someoneNotified = false;
|
|
|
- var queue = [];
|
|
|
- queue.push(moduleId);
|
|
|
- seenModuleId[moduleId] = true;
|
|
|
- while (queue.length > 0) {
|
|
|
- var queueElement = queue.shift();
|
|
|
- var m = this._modules2[queueElement];
|
|
|
- if (m) {
|
|
|
- someoneNotified = m.onDependencyError(error) || someoneNotified;
|
|
|
- }
|
|
|
- var inverseDeps = this._inverseDependencies2[queueElement];
|
|
|
- if (inverseDeps) {
|
|
|
- for (var i = 0, len = inverseDeps.length; i < len; i++) {
|
|
|
- var inverseDep = inverseDeps[i];
|
|
|
- if (!seenModuleId[inverseDep]) {
|
|
|
- queue.push(inverseDep);
|
|
|
- seenModuleId[inverseDep] = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (!someoneNotified) {
|
|
|
- this._config.onError(error);
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * Walks (recursively) the dependencies of 'from' in search of 'to'.
|
|
|
- * Returns true if there is such a path or false otherwise.
|
|
|
- * @param from Module id to start at
|
|
|
- * @param to Module id to look for
|
|
|
- */
|
|
|
- ModuleManager.prototype._hasDependencyPath = function (fromId, toId) {
|
|
|
- var from = this._modules2[fromId];
|
|
|
- if (!from) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- var inQueue = [];
|
|
|
- for (var i = 0, len = this._moduleIdProvider.getMaxModuleId(); i < len; i++) {
|
|
|
- inQueue[i] = false;
|
|
|
- }
|
|
|
- var queue = [];
|
|
|
- // Insert 'from' in queue
|
|
|
- queue.push(from);
|
|
|
- inQueue[fromId] = true;
|
|
|
- while (queue.length > 0) {
|
|
|
- // Pop first inserted element of queue
|
|
|
- var element = queue.shift();
|
|
|
- var dependencies = element.dependencies;
|
|
|
- if (dependencies) {
|
|
|
- // Walk the element's dependencies
|
|
|
- for (var i = 0, len = dependencies.length; i < len; i++) {
|
|
|
- var dependency = dependencies[i];
|
|
|
- if (dependency.id === toId) {
|
|
|
- // There is a path to 'to'
|
|
|
- return true;
|
|
|
- }
|
|
|
- var dependencyModule = this._modules2[dependency.id];
|
|
|
- if (dependencyModule && !inQueue[dependency.id]) {
|
|
|
- // Insert 'dependency' in queue
|
|
|
- inQueue[dependency.id] = true;
|
|
|
- queue.push(dependencyModule);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // There is no path to 'to'
|
|
|
- return false;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Walks (recursively) the dependencies of 'from' in search of 'to'.
|
|
|
- * Returns cycle as array.
|
|
|
- * @param from Module id to start at
|
|
|
- * @param to Module id to look for
|
|
|
- */
|
|
|
- ModuleManager.prototype._findCyclePath = function (fromId, toId, depth) {
|
|
|
- if (fromId === toId || depth === 50) {
|
|
|
- return [fromId];
|
|
|
- }
|
|
|
- var from = this._modules2[fromId];
|
|
|
- if (!from) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- // Walk the element's dependencies
|
|
|
- var dependencies = from.dependencies;
|
|
|
- for (var i = 0, len = dependencies.length; i < len; i++) {
|
|
|
- var path = this._findCyclePath(dependencies[i].id, toId, depth + 1);
|
|
|
- if (path !== null) {
|
|
|
- path.push(fromId);
|
|
|
- return path;
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create the local 'require' that is passed into modules
|
|
|
- */
|
|
|
- ModuleManager.prototype._createRequire = function (moduleIdResolver) {
|
|
|
- var _this = this;
|
|
|
- var result = (function (dependencies, callback, errorback) {
|
|
|
- return _this._relativeRequire(moduleIdResolver, dependencies, callback, errorback);
|
|
|
- });
|
|
|
- result.toUrl = function (id) {
|
|
|
- return _this._config.requireToUrl(moduleIdResolver.resolveModule(id));
|
|
|
- };
|
|
|
- result.getStats = function () {
|
|
|
- return _this.getLoaderEvents();
|
|
|
- };
|
|
|
- result.__$__nodeRequire = AMDLoader.global.nodeRequire;
|
|
|
- return result;
|
|
|
- };
|
|
|
- ModuleManager.prototype._loadModule = function (moduleId) {
|
|
|
- var _this = this;
|
|
|
- if (this._modules2[moduleId] || this._knownModules2[moduleId]) {
|
|
|
- // known module
|
|
|
- return;
|
|
|
- }
|
|
|
- this._knownModules2[moduleId] = true;
|
|
|
- var strModuleId = this._moduleIdProvider.getStrModuleId(moduleId);
|
|
|
- var paths = this._config.moduleIdToPaths(strModuleId);
|
|
|
- if (this._env.isNode && strModuleId.indexOf('/') === -1) {
|
|
|
- paths.push('node|' + strModuleId);
|
|
|
- }
|
|
|
- var lastPathIndex = -1;
|
|
|
- var loadNextPath = function (err) {
|
|
|
- lastPathIndex++;
|
|
|
- if (lastPathIndex >= paths.length) {
|
|
|
- // No more paths to try
|
|
|
- _this._onLoadError(moduleId, err);
|
|
|
- }
|
|
|
- else {
|
|
|
- var currentPath_1 = paths[lastPathIndex];
|
|
|
- var recorder_1 = _this.getRecorder();
|
|
|
- if (_this._config.isBuild() && currentPath_1 === 'empty:') {
|
|
|
- _this._buildInfoPath[moduleId] = currentPath_1;
|
|
|
- _this.defineModule(_this._moduleIdProvider.getStrModuleId(moduleId), [], null, null, null);
|
|
|
- _this._onLoad(moduleId);
|
|
|
- return;
|
|
|
- }
|
|
|
- recorder_1.record(AMDLoader.LoaderEventType.BeginLoadingScript, currentPath_1);
|
|
|
- _this._scriptLoader.load(_this, currentPath_1, function () {
|
|
|
- if (_this._config.isBuild()) {
|
|
|
- _this._buildInfoPath[moduleId] = currentPath_1;
|
|
|
- }
|
|
|
- recorder_1.record(AMDLoader.LoaderEventType.EndLoadingScriptOK, currentPath_1);
|
|
|
- _this._onLoad(moduleId);
|
|
|
- }, function (err) {
|
|
|
- recorder_1.record(AMDLoader.LoaderEventType.EndLoadingScriptError, currentPath_1);
|
|
|
- loadNextPath(err);
|
|
|
- });
|
|
|
- }
|
|
|
- };
|
|
|
- loadNextPath(null);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Resolve a plugin dependency with the plugin loaded & complete
|
|
|
- * @param module The module that has this dependency
|
|
|
- * @param pluginDependency The semi-normalized dependency that appears in the module. e.g. 'vs/css!./mycssfile'. Only the plugin part (before !) is normalized
|
|
|
- * @param plugin The plugin (what the plugin exports)
|
|
|
- */
|
|
|
- ModuleManager.prototype._loadPluginDependency = function (plugin, pluginDependency) {
|
|
|
- var _this = this;
|
|
|
- if (this._modules2[pluginDependency.id] || this._knownModules2[pluginDependency.id]) {
|
|
|
- // known module
|
|
|
- return;
|
|
|
- }
|
|
|
- this._knownModules2[pluginDependency.id] = true;
|
|
|
- // Delegate the loading of the resource to the plugin
|
|
|
- var load = (function (value) {
|
|
|
- _this.defineModule(_this._moduleIdProvider.getStrModuleId(pluginDependency.id), [], value, null, null);
|
|
|
- });
|
|
|
- load.error = function (err) {
|
|
|
- _this._config.onError(_this._createLoadError(pluginDependency.id, err));
|
|
|
- };
|
|
|
- plugin.load(pluginDependency.pluginParam, this._createRequire(ModuleIdResolver.ROOT), load, this._config.getOptionsLiteral());
|
|
|
- };
|
|
|
- /**
|
|
|
- * Examine the dependencies of module 'module' and resolve them as needed.
|
|
|
- */
|
|
|
- ModuleManager.prototype._resolve = function (module) {
|
|
|
- var _this = this;
|
|
|
- var dependencies = module.dependencies;
|
|
|
- for (var i = 0, len = dependencies.length; i < len; i++) {
|
|
|
- var dependency = dependencies[i];
|
|
|
- if (dependency === RegularDependency.EXPORTS) {
|
|
|
- module.exportsPassedIn = true;
|
|
|
- module.unresolvedDependenciesCount--;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (dependency === RegularDependency.MODULE) {
|
|
|
- module.unresolvedDependenciesCount--;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (dependency === RegularDependency.REQUIRE) {
|
|
|
- module.unresolvedDependenciesCount--;
|
|
|
- continue;
|
|
|
- }
|
|
|
- var dependencyModule = this._modules2[dependency.id];
|
|
|
- if (dependencyModule && dependencyModule.isComplete()) {
|
|
|
- module.unresolvedDependenciesCount--;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (this._hasDependencyPath(dependency.id, module.id)) {
|
|
|
- console.warn('There is a dependency cycle between \'' + this._moduleIdProvider.getStrModuleId(dependency.id) + '\' and \'' + this._moduleIdProvider.getStrModuleId(module.id) + '\'. The cyclic path follows:');
|
|
|
- var cyclePath = this._findCyclePath(dependency.id, module.id, 0);
|
|
|
- cyclePath.reverse();
|
|
|
- cyclePath.push(dependency.id);
|
|
|
- console.warn(cyclePath.map(function (id) { return _this._moduleIdProvider.getStrModuleId(id); }).join(' => \n'));
|
|
|
- // Break the cycle
|
|
|
- module.unresolvedDependenciesCount--;
|
|
|
- continue;
|
|
|
- }
|
|
|
- // record inverse dependency
|
|
|
- this._inverseDependencies2[dependency.id] = this._inverseDependencies2[dependency.id] || [];
|
|
|
- this._inverseDependencies2[dependency.id].push(module.id);
|
|
|
- if (dependency instanceof PluginDependency) {
|
|
|
- var plugin = this._modules2[dependency.pluginId];
|
|
|
- if (plugin && plugin.isComplete()) {
|
|
|
- this._loadPluginDependency(plugin.exports, dependency);
|
|
|
- continue;
|
|
|
- }
|
|
|
- // Record dependency for when the plugin gets loaded
|
|
|
- var inversePluginDeps = this._inversePluginDependencies2.get(dependency.pluginId);
|
|
|
- if (!inversePluginDeps) {
|
|
|
- inversePluginDeps = [];
|
|
|
- this._inversePluginDependencies2.set(dependency.pluginId, inversePluginDeps);
|
|
|
- }
|
|
|
- inversePluginDeps.push(dependency);
|
|
|
- this._loadModule(dependency.pluginId);
|
|
|
- continue;
|
|
|
- }
|
|
|
- this._loadModule(dependency.id);
|
|
|
- }
|
|
|
- if (module.unresolvedDependenciesCount === 0) {
|
|
|
- this._onModuleComplete(module);
|
|
|
- }
|
|
|
- };
|
|
|
- ModuleManager.prototype._onModuleComplete = function (module) {
|
|
|
- var _this = this;
|
|
|
- var recorder = this.getRecorder();
|
|
|
- if (module.isComplete()) {
|
|
|
- // already done
|
|
|
- return;
|
|
|
- }
|
|
|
- var dependencies = module.dependencies;
|
|
|
- var dependenciesValues = [];
|
|
|
- for (var i = 0, len = dependencies.length; i < len; i++) {
|
|
|
- var dependency = dependencies[i];
|
|
|
- if (dependency === RegularDependency.EXPORTS) {
|
|
|
- dependenciesValues[i] = module.exports;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (dependency === RegularDependency.MODULE) {
|
|
|
- dependenciesValues[i] = {
|
|
|
- id: module.strId,
|
|
|
- config: function () {
|
|
|
- return _this._config.getConfigForModule(module.strId);
|
|
|
- }
|
|
|
- };
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (dependency === RegularDependency.REQUIRE) {
|
|
|
- dependenciesValues[i] = this._createRequire(module.moduleIdResolver);
|
|
|
- continue;
|
|
|
- }
|
|
|
- var dependencyModule = this._modules2[dependency.id];
|
|
|
- if (dependencyModule) {
|
|
|
- dependenciesValues[i] = dependencyModule.exports;
|
|
|
- continue;
|
|
|
- }
|
|
|
- dependenciesValues[i] = null;
|
|
|
- }
|
|
|
- module.complete(recorder, this._config, dependenciesValues);
|
|
|
- // Fetch and clear inverse dependencies
|
|
|
- var inverseDeps = this._inverseDependencies2[module.id];
|
|
|
- this._inverseDependencies2[module.id] = null;
|
|
|
- if (inverseDeps) {
|
|
|
- // Resolve one inverse dependency at a time, always
|
|
|
- // on the lookout for a completed module.
|
|
|
- for (var i = 0, len = inverseDeps.length; i < len; i++) {
|
|
|
- var inverseDependencyId = inverseDeps[i];
|
|
|
- var inverseDependency = this._modules2[inverseDependencyId];
|
|
|
- inverseDependency.unresolvedDependenciesCount--;
|
|
|
- if (inverseDependency.unresolvedDependenciesCount === 0) {
|
|
|
- this._onModuleComplete(inverseDependency);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- var inversePluginDeps = this._inversePluginDependencies2.get(module.id);
|
|
|
- if (inversePluginDeps) {
|
|
|
- // This module is used as a plugin at least once
|
|
|
- // Fetch and clear these inverse plugin dependencies
|
|
|
- this._inversePluginDependencies2.delete(module.id);
|
|
|
- // Resolve plugin dependencies one at a time
|
|
|
- for (var i = 0, len = inversePluginDeps.length; i < len; i++) {
|
|
|
- this._loadPluginDependency(module.exports, inversePluginDeps[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- return ModuleManager;
|
|
|
- }());
|
|
|
- AMDLoader.ModuleManager = ModuleManager;
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-var define;
|
|
|
-var AMDLoader;
|
|
|
-(function (AMDLoader) {
|
|
|
- var moduleManager = null;
|
|
|
- var DefineFunc = null;
|
|
|
- var RequireFunc = null;
|
|
|
- function createGlobalAMDFuncs() {
|
|
|
- var _defineFunc = function (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'];
|
|
|
- }
|
|
|
- if (id) {
|
|
|
- moduleManager.defineModule(id, dependencies, callback, null, null);
|
|
|
- }
|
|
|
- else {
|
|
|
- moduleManager.enqueueDefineAnonymousModule(dependencies, callback);
|
|
|
- }
|
|
|
- };
|
|
|
- DefineFunc = _defineFunc;
|
|
|
- DefineFunc.amd = {
|
|
|
- jQuery: true
|
|
|
- };
|
|
|
- var _requireFunc_config = function (params, shouldOverwrite) {
|
|
|
- if (shouldOverwrite === void 0) { shouldOverwrite = false; }
|
|
|
- moduleManager.configure(params, shouldOverwrite);
|
|
|
- };
|
|
|
- var _requireFunc = function () {
|
|
|
- if (arguments.length === 1) {
|
|
|
- if ((arguments[0] instanceof Object) && !Array.isArray(arguments[0])) {
|
|
|
- _requireFunc_config(arguments[0]);
|
|
|
- return;
|
|
|
- }
|
|
|
- if (typeof arguments[0] === 'string') {
|
|
|
- return moduleManager.synchronousRequire(arguments[0]);
|
|
|
- }
|
|
|
- }
|
|
|
- if (arguments.length === 2 || arguments.length === 3) {
|
|
|
- if (Array.isArray(arguments[0])) {
|
|
|
- moduleManager.defineModule(AMDLoader.Utilities.generateAnonymousModule(), arguments[0], arguments[1], arguments[2], null);
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- throw new Error('Unrecognized require call');
|
|
|
- };
|
|
|
- RequireFunc = _requireFunc;
|
|
|
- RequireFunc.config = _requireFunc_config;
|
|
|
- RequireFunc.getConfig = function () {
|
|
|
- return moduleManager.getConfig().getOptionsLiteral();
|
|
|
- };
|
|
|
- RequireFunc.reset = function () {
|
|
|
- moduleManager = moduleManager.reset();
|
|
|
- };
|
|
|
- RequireFunc.getBuildInfo = function () {
|
|
|
- return moduleManager.getBuildInfo();
|
|
|
- };
|
|
|
- RequireFunc.getStats = function () {
|
|
|
- return moduleManager.getLoaderEvents();
|
|
|
- };
|
|
|
- }
|
|
|
- function init() {
|
|
|
- createGlobalAMDFuncs();
|
|
|
- var env = AMDLoader.Environment.detect();
|
|
|
- var scriptLoader = AMDLoader.createScriptLoader(env);
|
|
|
- moduleManager = new AMDLoader.ModuleManager(env, scriptLoader, DefineFunc, RequireFunc, AMDLoader.Utilities.getHighPerformanceTimestamp());
|
|
|
- if (env.isNode) {
|
|
|
- var _nodeRequire = (AMDLoader.global.require || require);
|
|
|
- var nodeRequire = function (what) {
|
|
|
- moduleManager.getRecorder().record(AMDLoader.LoaderEventType.NodeBeginNativeRequire, what);
|
|
|
- try {
|
|
|
- return _nodeRequire(what);
|
|
|
- }
|
|
|
- finally {
|
|
|
- moduleManager.getRecorder().record(AMDLoader.LoaderEventType.NodeEndNativeRequire, what);
|
|
|
- }
|
|
|
- };
|
|
|
- AMDLoader.global.nodeRequire = nodeRequire;
|
|
|
- RequireFunc.nodeRequire = nodeRequire;
|
|
|
- }
|
|
|
- if (env.isNode && !env.isElectronRenderer) {
|
|
|
- module.exports = RequireFunc;
|
|
|
- // These two defs are fore the local closure defined in node in the case that the loader is concatenated
|
|
|
- define = function () {
|
|
|
- DefineFunc.apply(null, arguments);
|
|
|
- };
|
|
|
- require = RequireFunc;
|
|
|
- }
|
|
|
- else {
|
|
|
- // The global variable require can configure the loader
|
|
|
- if (typeof AMDLoader.global.require !== 'undefined' && typeof AMDLoader.global.require !== 'function') {
|
|
|
- RequireFunc.config(AMDLoader.global.require);
|
|
|
- }
|
|
|
- if (!env.isElectronRenderer) {
|
|
|
- AMDLoader.global.define = define = DefineFunc;
|
|
|
- }
|
|
|
- else {
|
|
|
- define = function () {
|
|
|
- DefineFunc.apply(null, arguments);
|
|
|
- };
|
|
|
- }
|
|
|
- AMDLoader.global.require = RequireFunc;
|
|
|
- AMDLoader.global.require.__$__nodeRequire = nodeRequire;
|
|
|
- }
|
|
|
- }
|
|
|
- AMDLoader.init = init;
|
|
|
- if (typeof doNotInitLoader === 'undefined' &&
|
|
|
- (typeof AMDLoader.global.define !== 'function' || !AMDLoader.global.define.amd)) {
|
|
|
- init();
|
|
|
- }
|
|
|
-})(AMDLoader || (AMDLoader = {}));
|
|
|
-
|
|
|
-define(__m[16/*vs/base/common/diff/diffChange*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- exports.DifferenceType = {
|
|
|
- Add: 0,
|
|
|
- Remove: 1,
|
|
|
- Change: 2
|
|
|
- };
|
|
|
- /**
|
|
|
- * Represents information about a specific difference between two sequences.
|
|
|
- */
|
|
|
- var DiffChange = (function () {
|
|
|
- /**
|
|
|
- * Constructs a new DiffChange with the given sequence information
|
|
|
- * and content.
|
|
|
- */
|
|
|
- function DiffChange(originalStart, originalLength, modifiedStart, modifiedLength) {
|
|
|
- //Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");
|
|
|
- this.originalStart = originalStart;
|
|
|
- this.originalLength = originalLength;
|
|
|
- this.modifiedStart = modifiedStart;
|
|
|
- this.modifiedLength = modifiedLength;
|
|
|
- }
|
|
|
- /**
|
|
|
- * The type of difference.
|
|
|
- */
|
|
|
- DiffChange.prototype.getChangeType = function () {
|
|
|
- if (this.originalLength === 0) {
|
|
|
- return exports.DifferenceType.Add;
|
|
|
- }
|
|
|
- else if (this.modifiedLength === 0) {
|
|
|
- return exports.DifferenceType.Remove;
|
|
|
- }
|
|
|
- else {
|
|
|
- return exports.DifferenceType.Change;
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * The end point (exclusive) of the change in the original sequence.
|
|
|
- */
|
|
|
- DiffChange.prototype.getOriginalEnd = function () {
|
|
|
- return this.originalStart + this.originalLength;
|
|
|
- };
|
|
|
- /**
|
|
|
- * The end point (exclusive) of the change in the modified sequence.
|
|
|
- */
|
|
|
- DiffChange.prototype.getModifiedEnd = function () {
|
|
|
- return this.modifiedStart + this.modifiedLength;
|
|
|
- };
|
|
|
- return DiffChange;
|
|
|
- }());
|
|
|
- exports.DiffChange = DiffChange;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[12/*vs/base/common/diff/diff*/], __M([1/*require*/,0/*exports*/,16/*vs/base/common/diff/diffChange*/]), function (require, exports, diffChange_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- function createStringSequence(a) {
|
|
|
- return {
|
|
|
- getLength: function () { return a.length; },
|
|
|
- getElementHash: function (pos) { return a[pos]; }
|
|
|
- };
|
|
|
- }
|
|
|
- function stringDiff(original, modified) {
|
|
|
- return new LcsDiff(createStringSequence(original), createStringSequence(modified)).ComputeDiff();
|
|
|
- }
|
|
|
- exports.stringDiff = stringDiff;
|
|
|
- //
|
|
|
- // The code below has been ported from a C# implementation in VS
|
|
|
- //
|
|
|
- var Debug = (function () {
|
|
|
- function Debug() {
|
|
|
- }
|
|
|
- Debug.Assert = function (condition, message) {
|
|
|
- if (!condition) {
|
|
|
- throw new Error(message);
|
|
|
- }
|
|
|
- };
|
|
|
- return Debug;
|
|
|
- }());
|
|
|
- exports.Debug = Debug;
|
|
|
- var MyArray = (function () {
|
|
|
- function MyArray() {
|
|
|
- }
|
|
|
- /**
|
|
|
- * Copies a range of elements from an Array starting at the specified source index and pastes
|
|
|
- * them to another Array starting at the specified destination index. The length and the indexes
|
|
|
- * are specified as 64-bit integers.
|
|
|
- * sourceArray:
|
|
|
- * The Array that contains the data to copy.
|
|
|
- * sourceIndex:
|
|
|
- * A 64-bit integer that represents the index in the sourceArray at which copying begins.
|
|
|
- * destinationArray:
|
|
|
- * The Array that receives the data.
|
|
|
- * destinationIndex:
|
|
|
- * A 64-bit integer that represents the index in the destinationArray at which storing begins.
|
|
|
- * length:
|
|
|
- * A 64-bit integer that represents the number of elements to copy.
|
|
|
- */
|
|
|
- MyArray.Copy = function (sourceArray, sourceIndex, destinationArray, destinationIndex, length) {
|
|
|
- for (var i = 0; i < length; i++) {
|
|
|
- destinationArray[destinationIndex + i] = sourceArray[sourceIndex + i];
|
|
|
- }
|
|
|
- };
|
|
|
- return MyArray;
|
|
|
- }());
|
|
|
- exports.MyArray = MyArray;
|
|
|
- //*****************************************************************************
|
|
|
- // LcsDiff.cs
|
|
|
- //
|
|
|
- // An implementation of the difference algorithm described in
|
|
|
- // "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
|
|
|
- //
|
|
|
- // Copyright (C) 2008 Microsoft Corporation @minifier_do_not_preserve
|
|
|
- //*****************************************************************************
|
|
|
- // Our total memory usage for storing history is (worst-case):
|
|
|
- // 2 * [(MaxDifferencesHistory + 1) * (MaxDifferencesHistory + 1) - 1] * sizeof(int)
|
|
|
- // 2 * [1448*1448 - 1] * 4 = 16773624 = 16MB
|
|
|
- var MaxDifferencesHistory = 1447;
|
|
|
- //let MaxDifferencesHistory = 100;
|
|
|
- /**
|
|
|
- * A utility class which helps to create the set of DiffChanges from
|
|
|
- * a difference operation. This class accepts original DiffElements and
|
|
|
- * modified DiffElements that are involved in a particular change. The
|
|
|
- * MarktNextChange() method can be called to mark the separation between
|
|
|
- * distinct changes. At the end, the Changes property can be called to retrieve
|
|
|
- * the constructed changes.
|
|
|
- */
|
|
|
- var DiffChangeHelper = (function () {
|
|
|
- /**
|
|
|
- * Constructs a new DiffChangeHelper for the given DiffSequences.
|
|
|
- */
|
|
|
- function DiffChangeHelper() {
|
|
|
- this.m_changes = [];
|
|
|
- this.m_originalStart = Number.MAX_VALUE;
|
|
|
- this.m_modifiedStart = Number.MAX_VALUE;
|
|
|
- this.m_originalCount = 0;
|
|
|
- this.m_modifiedCount = 0;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Marks the beginning of the next change in the set of differences.
|
|
|
- */
|
|
|
- DiffChangeHelper.prototype.MarkNextChange = function () {
|
|
|
- // Only add to the list if there is something to add
|
|
|
- if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
|
|
|
- // Add the new change to our list
|
|
|
- this.m_changes.push(new diffChange_1.DiffChange(this.m_originalStart, this.m_originalCount, this.m_modifiedStart, this.m_modifiedCount));
|
|
|
- }
|
|
|
- // Reset for the next change
|
|
|
- this.m_originalCount = 0;
|
|
|
- this.m_modifiedCount = 0;
|
|
|
- this.m_originalStart = Number.MAX_VALUE;
|
|
|
- this.m_modifiedStart = Number.MAX_VALUE;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Adds the original element at the given position to the elements
|
|
|
- * affected by the current change. The modified index gives context
|
|
|
- * to the change position with respect to the original sequence.
|
|
|
- * @param originalIndex The index of the original element to add.
|
|
|
- * @param modifiedIndex The index of the modified element that provides corresponding position in the modified sequence.
|
|
|
- */
|
|
|
- DiffChangeHelper.prototype.AddOriginalElement = function (originalIndex, modifiedIndex) {
|
|
|
- // The 'true' start index is the smallest of the ones we've seen
|
|
|
- this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
|
|
|
- this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
|
|
|
- this.m_originalCount++;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Adds the modified element at the given position to the elements
|
|
|
- * affected by the current change. The original index gives context
|
|
|
- * to the change position with respect to the modified sequence.
|
|
|
- * @param originalIndex The index of the original element that provides corresponding position in the original sequence.
|
|
|
- * @param modifiedIndex The index of the modified element to add.
|
|
|
- */
|
|
|
- DiffChangeHelper.prototype.AddModifiedElement = function (originalIndex, modifiedIndex) {
|
|
|
- // The 'true' start index is the smallest of the ones we've seen
|
|
|
- this.m_originalStart = Math.min(this.m_originalStart, originalIndex);
|
|
|
- this.m_modifiedStart = Math.min(this.m_modifiedStart, modifiedIndex);
|
|
|
- this.m_modifiedCount++;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Retrieves all of the changes marked by the class.
|
|
|
- */
|
|
|
- DiffChangeHelper.prototype.getChanges = function () {
|
|
|
- if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
|
|
|
- // Finish up on whatever is left
|
|
|
- this.MarkNextChange();
|
|
|
- }
|
|
|
- return this.m_changes;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Retrieves all of the changes marked by the class in the reverse order
|
|
|
- */
|
|
|
- DiffChangeHelper.prototype.getReverseChanges = function () {
|
|
|
- if (this.m_originalCount > 0 || this.m_modifiedCount > 0) {
|
|
|
- // Finish up on whatever is left
|
|
|
- this.MarkNextChange();
|
|
|
- }
|
|
|
- this.m_changes.reverse();
|
|
|
- return this.m_changes;
|
|
|
- };
|
|
|
- return DiffChangeHelper;
|
|
|
- }());
|
|
|
- var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
- /**
|
|
|
- * An implementation of the difference algorithm described in
|
|
|
- * "An O(ND) Difference Algorithm and its letiations" by Eugene W. Myers
|
|
|
- */
|
|
|
- var LcsDiff = (function () {
|
|
|
- /**
|
|
|
- * Constructs the DiffFinder
|
|
|
- */
|
|
|
- function LcsDiff(originalSequence, newSequence, continueProcessingPredicate) {
|
|
|
- if (continueProcessingPredicate === void 0) { continueProcessingPredicate = null; }
|
|
|
- this.OriginalSequence = originalSequence;
|
|
|
- this.ModifiedSequence = newSequence;
|
|
|
- this.ContinueProcessingPredicate = continueProcessingPredicate;
|
|
|
- this.m_originalIds = [];
|
|
|
- this.m_modifiedIds = [];
|
|
|
- this.m_forwardHistory = [];
|
|
|
- this.m_reverseHistory = [];
|
|
|
- this.ComputeUniqueIdentifiers();
|
|
|
- }
|
|
|
- LcsDiff.prototype.ComputeUniqueIdentifiers = function () {
|
|
|
- var originalSequenceLength = this.OriginalSequence.getLength();
|
|
|
- var modifiedSequenceLength = this.ModifiedSequence.getLength();
|
|
|
- this.m_originalIds = new Array(originalSequenceLength);
|
|
|
- this.m_modifiedIds = new Array(modifiedSequenceLength);
|
|
|
- // Create a new hash table for unique elements from the original
|
|
|
- // sequence.
|
|
|
- var hashTable = {};
|
|
|
- var currentUniqueId = 1;
|
|
|
- var i;
|
|
|
- // Fill up the hash table for unique elements
|
|
|
- for (i = 0; i < originalSequenceLength; i++) {
|
|
|
- var originalElementHash = this.OriginalSequence.getElementHash(i);
|
|
|
- if (!hasOwnProperty.call(hashTable, originalElementHash)) {
|
|
|
- // No entry in the hashtable so this is a new unique element.
|
|
|
- // Assign the element a new unique identifier and add it to the
|
|
|
- // hash table
|
|
|
- this.m_originalIds[i] = currentUniqueId++;
|
|
|
- hashTable[originalElementHash] = this.m_originalIds[i];
|
|
|
- }
|
|
|
- else {
|
|
|
- this.m_originalIds[i] = hashTable[originalElementHash];
|
|
|
- }
|
|
|
- }
|
|
|
- // Now match up modified elements
|
|
|
- for (i = 0; i < modifiedSequenceLength; i++) {
|
|
|
- var modifiedElementHash = this.ModifiedSequence.getElementHash(i);
|
|
|
- if (!hasOwnProperty.call(hashTable, modifiedElementHash)) {
|
|
|
- this.m_modifiedIds[i] = currentUniqueId++;
|
|
|
- hashTable[modifiedElementHash] = this.m_modifiedIds[i];
|
|
|
- }
|
|
|
- else {
|
|
|
- this.m_modifiedIds[i] = hashTable[modifiedElementHash];
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- LcsDiff.prototype.ElementsAreEqual = function (originalIndex, newIndex) {
|
|
|
- return this.m_originalIds[originalIndex] === this.m_modifiedIds[newIndex];
|
|
|
- };
|
|
|
- LcsDiff.prototype.ComputeDiff = function () {
|
|
|
- return this._ComputeDiff(0, this.OriginalSequence.getLength() - 1, 0, this.ModifiedSequence.getLength() - 1);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Computes the differences between the original and modified input
|
|
|
- * sequences on the bounded range.
|
|
|
- * @returns An array of the differences between the two input sequences.
|
|
|
- */
|
|
|
- LcsDiff.prototype._ComputeDiff = function (originalStart, originalEnd, modifiedStart, modifiedEnd) {
|
|
|
- var quitEarlyArr = [false];
|
|
|
- return this.ComputeDiffRecursive(originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Private helper method which computes the differences on the bounded range
|
|
|
- * recursively.
|
|
|
- * @returns An array of the differences between the two input sequences.
|
|
|
- */
|
|
|
- LcsDiff.prototype.ComputeDiffRecursive = function (originalStart, originalEnd, modifiedStart, modifiedEnd, quitEarlyArr) {
|
|
|
- quitEarlyArr[0] = false;
|
|
|
- // Find the start of the differences
|
|
|
- while (originalStart <= originalEnd && modifiedStart <= modifiedEnd && this.ElementsAreEqual(originalStart, modifiedStart)) {
|
|
|
- originalStart++;
|
|
|
- modifiedStart++;
|
|
|
- }
|
|
|
- // Find the end of the differences
|
|
|
- while (originalEnd >= originalStart && modifiedEnd >= modifiedStart && this.ElementsAreEqual(originalEnd, modifiedEnd)) {
|
|
|
- originalEnd--;
|
|
|
- modifiedEnd--;
|
|
|
- }
|
|
|
- // In the special case where we either have all insertions or all deletions or the sequences are identical
|
|
|
- if (originalStart > originalEnd || modifiedStart > modifiedEnd) {
|
|
|
- var changes = void 0;
|
|
|
- if (modifiedStart <= modifiedEnd) {
|
|
|
- Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
|
|
|
- // All insertions
|
|
|
- changes = [
|
|
|
- new diffChange_1.DiffChange(originalStart, 0, modifiedStart, modifiedEnd - modifiedStart + 1)
|
|
|
- ];
|
|
|
- }
|
|
|
- else if (originalStart <= originalEnd) {
|
|
|
- Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
|
|
|
- // All deletions
|
|
|
- changes = [
|
|
|
- new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, 0)
|
|
|
- ];
|
|
|
- }
|
|
|
- else {
|
|
|
- Debug.Assert(originalStart === originalEnd + 1, 'originalStart should only be one more than originalEnd');
|
|
|
- Debug.Assert(modifiedStart === modifiedEnd + 1, 'modifiedStart should only be one more than modifiedEnd');
|
|
|
- // Identical sequences - No differences
|
|
|
- changes = [];
|
|
|
- }
|
|
|
- return changes;
|
|
|
- }
|
|
|
- // This problem can be solved using the Divide-And-Conquer technique.
|
|
|
- var midOriginalArr = [0], midModifiedArr = [0];
|
|
|
- var result = this.ComputeRecursionPoint(originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr);
|
|
|
- var midOriginal = midOriginalArr[0];
|
|
|
- var midModified = midModifiedArr[0];
|
|
|
- if (result !== null) {
|
|
|
- // Result is not-null when there was enough memory to compute the changes while
|
|
|
- // searching for the recursion point
|
|
|
- return result;
|
|
|
- }
|
|
|
- else if (!quitEarlyArr[0]) {
|
|
|
- // We can break the problem down recursively by finding the changes in the
|
|
|
- // First Half: (originalStart, modifiedStart) to (midOriginal, midModified)
|
|
|
- // Second Half: (midOriginal + 1, minModified + 1) to (originalEnd, modifiedEnd)
|
|
|
- // NOTE: ComputeDiff() is inclusive, therefore the second range starts on the next point
|
|
|
- var leftChanges = this.ComputeDiffRecursive(originalStart, midOriginal, modifiedStart, midModified, quitEarlyArr);
|
|
|
- var rightChanges = [];
|
|
|
- if (!quitEarlyArr[0]) {
|
|
|
- rightChanges = this.ComputeDiffRecursive(midOriginal + 1, originalEnd, midModified + 1, modifiedEnd, quitEarlyArr);
|
|
|
- }
|
|
|
- else {
|
|
|
- // We did't have time to finish the first half, so we don't have time to compute this half.
|
|
|
- // Consider the entire rest of the sequence different.
|
|
|
- rightChanges = [
|
|
|
- new diffChange_1.DiffChange(midOriginal + 1, originalEnd - (midOriginal + 1) + 1, midModified + 1, modifiedEnd - (midModified + 1) + 1)
|
|
|
- ];
|
|
|
- }
|
|
|
- return this.ConcatenateChanges(leftChanges, rightChanges);
|
|
|
- }
|
|
|
- // If we hit here, we quit early, and so can't return anything meaningful
|
|
|
- return [
|
|
|
- new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)
|
|
|
- ];
|
|
|
- };
|
|
|
- LcsDiff.prototype.WALKTRACE = function (diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr) {
|
|
|
- var forwardChanges = null, reverseChanges = null;
|
|
|
- // First, walk backward through the forward diagonals history
|
|
|
- var changeHelper = new DiffChangeHelper();
|
|
|
- var diagonalMin = diagonalForwardStart;
|
|
|
- var diagonalMax = diagonalForwardEnd;
|
|
|
- var diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalForwardOffset;
|
|
|
- var lastOriginalIndex = Number.MIN_VALUE;
|
|
|
- var historyIndex = this.m_forwardHistory.length - 1;
|
|
|
- var diagonal;
|
|
|
- do {
|
|
|
- // Get the diagonal index from the relative diagonal number
|
|
|
- diagonal = diagonalRelative + diagonalForwardBase;
|
|
|
- // Figure out where we came from
|
|
|
- if (diagonal === diagonalMin || (diagonal < diagonalMax && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {
|
|
|
- // Vertical line (the element is an insert)
|
|
|
- originalIndex = forwardPoints[diagonal + 1];
|
|
|
- modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
|
|
|
- if (originalIndex < lastOriginalIndex) {
|
|
|
- changeHelper.MarkNextChange();
|
|
|
- }
|
|
|
- lastOriginalIndex = originalIndex;
|
|
|
- changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex);
|
|
|
- diagonalRelative = (diagonal + 1) - diagonalForwardBase; //Setup for the next iteration
|
|
|
- }
|
|
|
- else {
|
|
|
- // Horizontal line (the element is a deletion)
|
|
|
- originalIndex = forwardPoints[diagonal - 1] + 1;
|
|
|
- modifiedIndex = originalIndex - diagonalRelative - diagonalForwardOffset;
|
|
|
- if (originalIndex < lastOriginalIndex) {
|
|
|
- changeHelper.MarkNextChange();
|
|
|
- }
|
|
|
- lastOriginalIndex = originalIndex - 1;
|
|
|
- changeHelper.AddOriginalElement(originalIndex, modifiedIndex + 1);
|
|
|
- diagonalRelative = (diagonal - 1) - diagonalForwardBase; //Setup for the next iteration
|
|
|
- }
|
|
|
- if (historyIndex >= 0) {
|
|
|
- forwardPoints = this.m_forwardHistory[historyIndex];
|
|
|
- diagonalForwardBase = forwardPoints[0]; //We stored this in the first spot
|
|
|
- diagonalMin = 1;
|
|
|
- diagonalMax = forwardPoints.length - 1;
|
|
|
- }
|
|
|
- } while (--historyIndex >= -1);
|
|
|
- // Ironically, we get the forward changes as the reverse of the
|
|
|
- // order we added them since we technically added them backwards
|
|
|
- forwardChanges = changeHelper.getReverseChanges();
|
|
|
- if (quitEarlyArr[0]) {
|
|
|
- // TODO: Calculate a partial from the reverse diagonals.
|
|
|
- // For now, just assume everything after the midOriginal/midModified point is a diff
|
|
|
- var originalStartPoint = midOriginalArr[0] + 1;
|
|
|
- var modifiedStartPoint = midModifiedArr[0] + 1;
|
|
|
- if (forwardChanges !== null && forwardChanges.length > 0) {
|
|
|
- var lastForwardChange = forwardChanges[forwardChanges.length - 1];
|
|
|
- originalStartPoint = Math.max(originalStartPoint, lastForwardChange.getOriginalEnd());
|
|
|
- modifiedStartPoint = Math.max(modifiedStartPoint, lastForwardChange.getModifiedEnd());
|
|
|
- }
|
|
|
- reverseChanges = [
|
|
|
- new diffChange_1.DiffChange(originalStartPoint, originalEnd - originalStartPoint + 1, modifiedStartPoint, modifiedEnd - modifiedStartPoint + 1)
|
|
|
- ];
|
|
|
- }
|
|
|
- else {
|
|
|
- // Now walk backward through the reverse diagonals history
|
|
|
- changeHelper = new DiffChangeHelper();
|
|
|
- diagonalMin = diagonalReverseStart;
|
|
|
- diagonalMax = diagonalReverseEnd;
|
|
|
- diagonalRelative = (midOriginalArr[0] - midModifiedArr[0]) - diagonalReverseOffset;
|
|
|
- lastOriginalIndex = Number.MAX_VALUE;
|
|
|
- historyIndex = (deltaIsEven) ? this.m_reverseHistory.length - 1 : this.m_reverseHistory.length - 2;
|
|
|
- do {
|
|
|
- // Get the diagonal index from the relative diagonal number
|
|
|
- diagonal = diagonalRelative + diagonalReverseBase;
|
|
|
- // Figure out where we came from
|
|
|
- if (diagonal === diagonalMin || (diagonal < diagonalMax && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {
|
|
|
- // Horizontal line (the element is a deletion))
|
|
|
- originalIndex = reversePoints[diagonal + 1] - 1;
|
|
|
- modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
|
|
|
- if (originalIndex > lastOriginalIndex) {
|
|
|
- changeHelper.MarkNextChange();
|
|
|
- }
|
|
|
- lastOriginalIndex = originalIndex + 1;
|
|
|
- changeHelper.AddOriginalElement(originalIndex + 1, modifiedIndex + 1);
|
|
|
- diagonalRelative = (diagonal + 1) - diagonalReverseBase; //Setup for the next iteration
|
|
|
- }
|
|
|
- else {
|
|
|
- // Vertical line (the element is an insertion)
|
|
|
- originalIndex = reversePoints[diagonal - 1];
|
|
|
- modifiedIndex = originalIndex - diagonalRelative - diagonalReverseOffset;
|
|
|
- if (originalIndex > lastOriginalIndex) {
|
|
|
- changeHelper.MarkNextChange();
|
|
|
- }
|
|
|
- lastOriginalIndex = originalIndex;
|
|
|
- changeHelper.AddModifiedElement(originalIndex + 1, modifiedIndex + 1);
|
|
|
- diagonalRelative = (diagonal - 1) - diagonalReverseBase; //Setup for the next iteration
|
|
|
- }
|
|
|
- if (historyIndex >= 0) {
|
|
|
- reversePoints = this.m_reverseHistory[historyIndex];
|
|
|
- diagonalReverseBase = reversePoints[0]; //We stored this in the first spot
|
|
|
- diagonalMin = 1;
|
|
|
- diagonalMax = reversePoints.length - 1;
|
|
|
- }
|
|
|
- } while (--historyIndex >= -1);
|
|
|
- // There are cases where the reverse history will find diffs that
|
|
|
- // are correct, but not intuitive, so we need shift them.
|
|
|
- reverseChanges = changeHelper.getChanges();
|
|
|
- }
|
|
|
- return this.ConcatenateChanges(forwardChanges, reverseChanges);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Given the range to compute the diff on, this method finds the point:
|
|
|
- * (midOriginal, midModified)
|
|
|
- * that exists in the middle of the LCS of the two sequences and
|
|
|
- * is the point at which the LCS problem may be broken down recursively.
|
|
|
- * This method will try to keep the LCS trace in memory. If the LCS recursion
|
|
|
- * point is calculated and the full trace is available in memory, then this method
|
|
|
- * will return the change list.
|
|
|
- * @param originalStart The start bound of the original sequence range
|
|
|
- * @param originalEnd The end bound of the original sequence range
|
|
|
- * @param modifiedStart The start bound of the modified sequence range
|
|
|
- * @param modifiedEnd The end bound of the modified sequence range
|
|
|
- * @param midOriginal The middle point of the original sequence range
|
|
|
- * @param midModified The middle point of the modified sequence range
|
|
|
- * @returns The diff changes, if available, otherwise null
|
|
|
- */
|
|
|
- LcsDiff.prototype.ComputeRecursionPoint = function (originalStart, originalEnd, modifiedStart, modifiedEnd, midOriginalArr, midModifiedArr, quitEarlyArr) {
|
|
|
- var originalIndex, modifiedIndex;
|
|
|
- var diagonalForwardStart = 0, diagonalForwardEnd = 0;
|
|
|
- var diagonalReverseStart = 0, diagonalReverseEnd = 0;
|
|
|
- var numDifferences;
|
|
|
- // To traverse the edit graph and produce the proper LCS, our actual
|
|
|
- // start position is just outside the given boundary
|
|
|
- originalStart--;
|
|
|
- modifiedStart--;
|
|
|
- // We set these up to make the compiler happy, but they will
|
|
|
- // be replaced before we return with the actual recursion point
|
|
|
- midOriginalArr[0] = 0;
|
|
|
- midModifiedArr[0] = 0;
|
|
|
- // Clear out the history
|
|
|
- this.m_forwardHistory = [];
|
|
|
- this.m_reverseHistory = [];
|
|
|
- // Each cell in the two arrays corresponds to a diagonal in the edit graph.
|
|
|
- // The integer value in the cell represents the originalIndex of the furthest
|
|
|
- // reaching point found so far that ends in that diagonal.
|
|
|
- // The modifiedIndex can be computed mathematically from the originalIndex and the diagonal number.
|
|
|
- var maxDifferences = (originalEnd - originalStart) + (modifiedEnd - modifiedStart);
|
|
|
- var numDiagonals = maxDifferences + 1;
|
|
|
- var forwardPoints = new Array(numDiagonals);
|
|
|
- var reversePoints = new Array(numDiagonals);
|
|
|
- // diagonalForwardBase: Index into forwardPoints of the diagonal which passes through (originalStart, modifiedStart)
|
|
|
- // diagonalReverseBase: Index into reversePoints of the diagonal which passes through (originalEnd, modifiedEnd)
|
|
|
- var diagonalForwardBase = (modifiedEnd - modifiedStart);
|
|
|
- var diagonalReverseBase = (originalEnd - originalStart);
|
|
|
- // diagonalForwardOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
|
|
|
- // diagonal number (relative to diagonalForwardBase)
|
|
|
- // diagonalReverseOffset: Geometric offset which allows modifiedIndex to be computed from originalIndex and the
|
|
|
- // diagonal number (relative to diagonalReverseBase)
|
|
|
- var diagonalForwardOffset = (originalStart - modifiedStart);
|
|
|
- var diagonalReverseOffset = (originalEnd - modifiedEnd);
|
|
|
- // delta: The difference between the end diagonal and the start diagonal. This is used to relate diagonal numbers
|
|
|
- // relative to the start diagonal with diagonal numbers relative to the end diagonal.
|
|
|
- // The Even/Oddn-ness of this delta is important for determining when we should check for overlap
|
|
|
- var delta = diagonalReverseBase - diagonalForwardBase;
|
|
|
- var deltaIsEven = (delta % 2 === 0);
|
|
|
- // Here we set up the start and end points as the furthest points found so far
|
|
|
- // in both the forward and reverse directions, respectively
|
|
|
- forwardPoints[diagonalForwardBase] = originalStart;
|
|
|
- reversePoints[diagonalReverseBase] = originalEnd;
|
|
|
- // Remember if we quit early, and thus need to do a best-effort result instead of a real result.
|
|
|
- quitEarlyArr[0] = false;
|
|
|
- // A couple of points:
|
|
|
- // --With this method, we iterate on the number of differences between the two sequences.
|
|
|
- // The more differences there actually are, the longer this will take.
|
|
|
- // --Also, as the number of differences increases, we have to search on diagonals further
|
|
|
- // away from the reference diagonal (which is diagonalForwardBase for forward, diagonalReverseBase for reverse).
|
|
|
- // --We extend on even diagonals (relative to the reference diagonal) only when numDifferences
|
|
|
- // is even and odd diagonals only when numDifferences is odd.
|
|
|
- var diagonal, tempOriginalIndex;
|
|
|
- for (numDifferences = 1; numDifferences <= (maxDifferences / 2) + 1; numDifferences++) {
|
|
|
- var furthestOriginalIndex = 0;
|
|
|
- var furthestModifiedIndex = 0;
|
|
|
- // Run the algorithm in the forward direction
|
|
|
- diagonalForwardStart = this.ClipDiagonalBound(diagonalForwardBase - numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
|
|
|
- diagonalForwardEnd = this.ClipDiagonalBound(diagonalForwardBase + numDifferences, numDifferences, diagonalForwardBase, numDiagonals);
|
|
|
- for (diagonal = diagonalForwardStart; diagonal <= diagonalForwardEnd; diagonal += 2) {
|
|
|
- // STEP 1: We extend the furthest reaching point in the present diagonal
|
|
|
- // by looking at the diagonals above and below and picking the one whose point
|
|
|
- // is further away from the start point (originalStart, modifiedStart)
|
|
|
- if (diagonal === diagonalForwardStart || (diagonal < diagonalForwardEnd && forwardPoints[diagonal - 1] < forwardPoints[diagonal + 1])) {
|
|
|
- originalIndex = forwardPoints[diagonal + 1];
|
|
|
- }
|
|
|
- else {
|
|
|
- originalIndex = forwardPoints[diagonal - 1] + 1;
|
|
|
- }
|
|
|
- modifiedIndex = originalIndex - (diagonal - diagonalForwardBase) - diagonalForwardOffset;
|
|
|
- // Save the current originalIndex so we can test for false overlap in step 3
|
|
|
- tempOriginalIndex = originalIndex;
|
|
|
- // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
|
|
|
- // so long as the elements are equal.
|
|
|
- while (originalIndex < originalEnd && modifiedIndex < modifiedEnd && this.ElementsAreEqual(originalIndex + 1, modifiedIndex + 1)) {
|
|
|
- originalIndex++;
|
|
|
- modifiedIndex++;
|
|
|
- }
|
|
|
- forwardPoints[diagonal] = originalIndex;
|
|
|
- if (originalIndex + modifiedIndex > furthestOriginalIndex + furthestModifiedIndex) {
|
|
|
- furthestOriginalIndex = originalIndex;
|
|
|
- furthestModifiedIndex = modifiedIndex;
|
|
|
- }
|
|
|
- // STEP 3: If delta is odd (overlap first happens on forward when delta is odd)
|
|
|
- // and diagonal is in the range of reverse diagonals computed for numDifferences-1
|
|
|
- // (the previous iteration; we haven't computed reverse diagonals for numDifferences yet)
|
|
|
- // then check for overlap.
|
|
|
- if (!deltaIsEven && Math.abs(diagonal - diagonalReverseBase) <= (numDifferences - 1)) {
|
|
|
- if (originalIndex >= reversePoints[diagonal]) {
|
|
|
- midOriginalArr[0] = originalIndex;
|
|
|
- midModifiedArr[0] = modifiedIndex;
|
|
|
- if (tempOriginalIndex <= reversePoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {
|
|
|
- // BINGO! We overlapped, and we have the full trace in memory!
|
|
|
- return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
|
|
|
- }
|
|
|
- else {
|
|
|
- // Either false overlap, or we didn't have enough memory for the full trace
|
|
|
- // Just return the recursion point
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // Check to see if we should be quitting early, before moving on to the next iteration.
|
|
|
- var matchLengthOfLongest = ((furthestOriginalIndex - originalStart) + (furthestModifiedIndex - modifiedStart) - numDifferences) / 2;
|
|
|
- if (this.ContinueProcessingPredicate !== null && !this.ContinueProcessingPredicate(furthestOriginalIndex, this.OriginalSequence, matchLengthOfLongest)) {
|
|
|
- // We can't finish, so skip ahead to generating a result from what we have.
|
|
|
- quitEarlyArr[0] = true;
|
|
|
- // Use the furthest distance we got in the forward direction.
|
|
|
- midOriginalArr[0] = furthestOriginalIndex;
|
|
|
- midModifiedArr[0] = furthestModifiedIndex;
|
|
|
- if (matchLengthOfLongest > 0 && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {
|
|
|
- // Enough of the history is in memory to walk it backwards
|
|
|
- return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
|
|
|
- }
|
|
|
- else {
|
|
|
- // We didn't actually remember enough of the history.
|
|
|
- //Since we are quiting the diff early, we need to shift back the originalStart and modified start
|
|
|
- //back into the boundary limits since we decremented their value above beyond the boundary limit.
|
|
|
- originalStart++;
|
|
|
- modifiedStart++;
|
|
|
- return [
|
|
|
- new diffChange_1.DiffChange(originalStart, originalEnd - originalStart + 1, modifiedStart, modifiedEnd - modifiedStart + 1)
|
|
|
- ];
|
|
|
- }
|
|
|
- }
|
|
|
- // Run the algorithm in the reverse direction
|
|
|
- diagonalReverseStart = this.ClipDiagonalBound(diagonalReverseBase - numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
|
|
|
- diagonalReverseEnd = this.ClipDiagonalBound(diagonalReverseBase + numDifferences, numDifferences, diagonalReverseBase, numDiagonals);
|
|
|
- for (diagonal = diagonalReverseStart; diagonal <= diagonalReverseEnd; diagonal += 2) {
|
|
|
- // STEP 1: We extend the furthest reaching point in the present diagonal
|
|
|
- // by looking at the diagonals above and below and picking the one whose point
|
|
|
- // is further away from the start point (originalEnd, modifiedEnd)
|
|
|
- if (diagonal === diagonalReverseStart || (diagonal < diagonalReverseEnd && reversePoints[diagonal - 1] >= reversePoints[diagonal + 1])) {
|
|
|
- originalIndex = reversePoints[diagonal + 1] - 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- originalIndex = reversePoints[diagonal - 1];
|
|
|
- }
|
|
|
- modifiedIndex = originalIndex - (diagonal - diagonalReverseBase) - diagonalReverseOffset;
|
|
|
- // Save the current originalIndex so we can test for false overlap
|
|
|
- tempOriginalIndex = originalIndex;
|
|
|
- // STEP 2: We can continue to extend the furthest reaching point in the present diagonal
|
|
|
- // as long as the elements are equal.
|
|
|
- while (originalIndex > originalStart && modifiedIndex > modifiedStart && this.ElementsAreEqual(originalIndex, modifiedIndex)) {
|
|
|
- originalIndex--;
|
|
|
- modifiedIndex--;
|
|
|
- }
|
|
|
- reversePoints[diagonal] = originalIndex;
|
|
|
- // STEP 4: If delta is even (overlap first happens on reverse when delta is even)
|
|
|
- // and diagonal is in the range of forward diagonals computed for numDifferences
|
|
|
- // then check for overlap.
|
|
|
- if (deltaIsEven && Math.abs(diagonal - diagonalForwardBase) <= numDifferences) {
|
|
|
- if (originalIndex <= forwardPoints[diagonal]) {
|
|
|
- midOriginalArr[0] = originalIndex;
|
|
|
- midModifiedArr[0] = modifiedIndex;
|
|
|
- if (tempOriginalIndex >= forwardPoints[diagonal] && MaxDifferencesHistory > 0 && numDifferences <= (MaxDifferencesHistory + 1)) {
|
|
|
- // BINGO! We overlapped, and we have the full trace in memory!
|
|
|
- return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
|
|
|
- }
|
|
|
- else {
|
|
|
- // Either false overlap, or we didn't have enough memory for the full trace
|
|
|
- // Just return the recursion point
|
|
|
- return null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- // Save current vectors to history before the next iteration
|
|
|
- if (numDifferences <= MaxDifferencesHistory) {
|
|
|
- // We are allocating space for one extra int, which we fill with
|
|
|
- // the index of the diagonal base index
|
|
|
- var temp = new Array(diagonalForwardEnd - diagonalForwardStart + 2);
|
|
|
- temp[0] = diagonalForwardBase - diagonalForwardStart + 1;
|
|
|
- MyArray.Copy(forwardPoints, diagonalForwardStart, temp, 1, diagonalForwardEnd - diagonalForwardStart + 1);
|
|
|
- this.m_forwardHistory.push(temp);
|
|
|
- temp = new Array(diagonalReverseEnd - diagonalReverseStart + 2);
|
|
|
- temp[0] = diagonalReverseBase - diagonalReverseStart + 1;
|
|
|
- MyArray.Copy(reversePoints, diagonalReverseStart, temp, 1, diagonalReverseEnd - diagonalReverseStart + 1);
|
|
|
- this.m_reverseHistory.push(temp);
|
|
|
- }
|
|
|
- }
|
|
|
- // If we got here, then we have the full trace in history. We just have to convert it to a change list
|
|
|
- // NOTE: This part is a bit messy
|
|
|
- return this.WALKTRACE(diagonalForwardBase, diagonalForwardStart, diagonalForwardEnd, diagonalForwardOffset, diagonalReverseBase, diagonalReverseStart, diagonalReverseEnd, diagonalReverseOffset, forwardPoints, reversePoints, originalIndex, originalEnd, midOriginalArr, modifiedIndex, modifiedEnd, midModifiedArr, deltaIsEven, quitEarlyArr);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Concatenates the two input DiffChange lists and returns the resulting
|
|
|
- * list.
|
|
|
- * @param The left changes
|
|
|
- * @param The right changes
|
|
|
- * @returns The concatenated list
|
|
|
- */
|
|
|
- LcsDiff.prototype.ConcatenateChanges = function (left, right) {
|
|
|
- var mergedChangeArr = [];
|
|
|
- var result = null;
|
|
|
- if (left.length === 0 || right.length === 0) {
|
|
|
- return (right.length > 0) ? right : left;
|
|
|
- }
|
|
|
- else if (this.ChangesOverlap(left[left.length - 1], right[0], mergedChangeArr)) {
|
|
|
- // Since we break the problem down recursively, it is possible that we
|
|
|
- // might recurse in the middle of a change thereby splitting it into
|
|
|
- // two changes. Here in the combining stage, we detect and fuse those
|
|
|
- // changes back together
|
|
|
- result = new Array(left.length + right.length - 1);
|
|
|
- MyArray.Copy(left, 0, result, 0, left.length - 1);
|
|
|
- result[left.length - 1] = mergedChangeArr[0];
|
|
|
- MyArray.Copy(right, 1, result, left.length, right.length - 1);
|
|
|
- return result;
|
|
|
- }
|
|
|
- else {
|
|
|
- result = new Array(left.length + right.length);
|
|
|
- MyArray.Copy(left, 0, result, 0, left.length);
|
|
|
- MyArray.Copy(right, 0, result, left.length, right.length);
|
|
|
- return result;
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * Returns true if the two changes overlap and can be merged into a single
|
|
|
- * change
|
|
|
- * @param left The left change
|
|
|
- * @param right The right change
|
|
|
- * @param mergedChange The merged change if the two overlap, null otherwise
|
|
|
- * @returns True if the two changes overlap
|
|
|
- */
|
|
|
- LcsDiff.prototype.ChangesOverlap = function (left, right, mergedChangeArr) {
|
|
|
- Debug.Assert(left.originalStart <= right.originalStart, 'Left change is not less than or equal to right change');
|
|
|
- Debug.Assert(left.modifiedStart <= right.modifiedStart, 'Left change is not less than or equal to right change');
|
|
|
- if (left.originalStart + left.originalLength >= right.originalStart || left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
|
|
|
- var originalStart = left.originalStart;
|
|
|
- var originalLength = left.originalLength;
|
|
|
- var modifiedStart = left.modifiedStart;
|
|
|
- var modifiedLength = left.modifiedLength;
|
|
|
- if (left.originalStart + left.originalLength >= right.originalStart) {
|
|
|
- originalLength = right.originalStart + right.originalLength - left.originalStart;
|
|
|
- }
|
|
|
- if (left.modifiedStart + left.modifiedLength >= right.modifiedStart) {
|
|
|
- modifiedLength = right.modifiedStart + right.modifiedLength - left.modifiedStart;
|
|
|
- }
|
|
|
- mergedChangeArr[0] = new diffChange_1.DiffChange(originalStart, originalLength, modifiedStart, modifiedLength);
|
|
|
- return true;
|
|
|
- }
|
|
|
- else {
|
|
|
- mergedChangeArr[0] = null;
|
|
|
- return false;
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * Helper method used to clip a diagonal index to the range of valid
|
|
|
- * diagonals. This also decides whether or not the diagonal index,
|
|
|
- * if it exceeds the boundary, should be clipped to the boundary or clipped
|
|
|
- * one inside the boundary depending on the Even/Odd status of the boundary
|
|
|
- * and numDifferences.
|
|
|
- * @param diagonal The index of the diagonal to clip.
|
|
|
- * @param numDifferences The current number of differences being iterated upon.
|
|
|
- * @param diagonalBaseIndex The base reference diagonal.
|
|
|
- * @param numDiagonals The total number of diagonals.
|
|
|
- * @returns The clipped diagonal index.
|
|
|
- */
|
|
|
- LcsDiff.prototype.ClipDiagonalBound = function (diagonal, numDifferences, diagonalBaseIndex, numDiagonals) {
|
|
|
- if (diagonal >= 0 && diagonal < numDiagonals) {
|
|
|
- // Nothing to clip, its in range
|
|
|
- return diagonal;
|
|
|
- }
|
|
|
- // diagonalsBelow: The number of diagonals below the reference diagonal
|
|
|
- // diagonalsAbove: The number of diagonals above the reference diagonal
|
|
|
- var diagonalsBelow = diagonalBaseIndex;
|
|
|
- var diagonalsAbove = numDiagonals - diagonalBaseIndex - 1;
|
|
|
- var diffEven = (numDifferences % 2 === 0);
|
|
|
- if (diagonal < 0) {
|
|
|
- var lowerBoundEven = (diagonalsBelow % 2 === 0);
|
|
|
- return (diffEven === lowerBoundEven) ? 0 : 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- var upperBoundEven = (diagonalsAbove % 2 === 0);
|
|
|
- return (diffEven === upperBoundEven) ? numDiagonals - 1 : numDiagonals - 2;
|
|
|
- }
|
|
|
- };
|
|
|
- return LcsDiff;
|
|
|
- }());
|
|
|
- exports.LcsDiff = LcsDiff;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-define(__m[11/*vs/base/common/functional*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- function not(fn) {
|
|
|
- return function () {
|
|
|
- var args = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- args[_i] = arguments[_i];
|
|
|
- }
|
|
|
- return !fn.apply(void 0, args);
|
|
|
- };
|
|
|
- }
|
|
|
- exports.not = not;
|
|
|
- function once(fn) {
|
|
|
- var _this = this;
|
|
|
- var didCall = false;
|
|
|
- var result;
|
|
|
- return function () {
|
|
|
- if (didCall) {
|
|
|
- return result;
|
|
|
- }
|
|
|
- didCall = true;
|
|
|
- result = fn.apply(_this, arguments);
|
|
|
- return result;
|
|
|
- };
|
|
|
- }
|
|
|
- exports.once = once;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-define(__m[21/*vs/base/common/keyCodes*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * Virtual Key Codes, the value does not hold any inherent meaning.
|
|
|
- * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
|
|
|
- * But these are "more general", as they should work across browsers & OS`s.
|
|
|
- */
|
|
|
- var KeyCode;
|
|
|
- (function (KeyCode) {
|
|
|
- /**
|
|
|
- * Placed first to cover the 0 value of the enum.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["Unknown"] = 0] = "Unknown";
|
|
|
- KeyCode[KeyCode["Backspace"] = 1] = "Backspace";
|
|
|
- KeyCode[KeyCode["Tab"] = 2] = "Tab";
|
|
|
- KeyCode[KeyCode["Enter"] = 3] = "Enter";
|
|
|
- KeyCode[KeyCode["Shift"] = 4] = "Shift";
|
|
|
- KeyCode[KeyCode["Ctrl"] = 5] = "Ctrl";
|
|
|
- KeyCode[KeyCode["Alt"] = 6] = "Alt";
|
|
|
- KeyCode[KeyCode["PauseBreak"] = 7] = "PauseBreak";
|
|
|
- KeyCode[KeyCode["CapsLock"] = 8] = "CapsLock";
|
|
|
- KeyCode[KeyCode["Escape"] = 9] = "Escape";
|
|
|
- KeyCode[KeyCode["Space"] = 10] = "Space";
|
|
|
- KeyCode[KeyCode["PageUp"] = 11] = "PageUp";
|
|
|
- KeyCode[KeyCode["PageDown"] = 12] = "PageDown";
|
|
|
- KeyCode[KeyCode["End"] = 13] = "End";
|
|
|
- KeyCode[KeyCode["Home"] = 14] = "Home";
|
|
|
- KeyCode[KeyCode["LeftArrow"] = 15] = "LeftArrow";
|
|
|
- KeyCode[KeyCode["UpArrow"] = 16] = "UpArrow";
|
|
|
- KeyCode[KeyCode["RightArrow"] = 17] = "RightArrow";
|
|
|
- KeyCode[KeyCode["DownArrow"] = 18] = "DownArrow";
|
|
|
- KeyCode[KeyCode["Insert"] = 19] = "Insert";
|
|
|
- KeyCode[KeyCode["Delete"] = 20] = "Delete";
|
|
|
- KeyCode[KeyCode["KEY_0"] = 21] = "KEY_0";
|
|
|
- KeyCode[KeyCode["KEY_1"] = 22] = "KEY_1";
|
|
|
- KeyCode[KeyCode["KEY_2"] = 23] = "KEY_2";
|
|
|
- KeyCode[KeyCode["KEY_3"] = 24] = "KEY_3";
|
|
|
- KeyCode[KeyCode["KEY_4"] = 25] = "KEY_4";
|
|
|
- KeyCode[KeyCode["KEY_5"] = 26] = "KEY_5";
|
|
|
- KeyCode[KeyCode["KEY_6"] = 27] = "KEY_6";
|
|
|
- KeyCode[KeyCode["KEY_7"] = 28] = "KEY_7";
|
|
|
- KeyCode[KeyCode["KEY_8"] = 29] = "KEY_8";
|
|
|
- KeyCode[KeyCode["KEY_9"] = 30] = "KEY_9";
|
|
|
- KeyCode[KeyCode["KEY_A"] = 31] = "KEY_A";
|
|
|
- KeyCode[KeyCode["KEY_B"] = 32] = "KEY_B";
|
|
|
- KeyCode[KeyCode["KEY_C"] = 33] = "KEY_C";
|
|
|
- KeyCode[KeyCode["KEY_D"] = 34] = "KEY_D";
|
|
|
- KeyCode[KeyCode["KEY_E"] = 35] = "KEY_E";
|
|
|
- KeyCode[KeyCode["KEY_F"] = 36] = "KEY_F";
|
|
|
- KeyCode[KeyCode["KEY_G"] = 37] = "KEY_G";
|
|
|
- KeyCode[KeyCode["KEY_H"] = 38] = "KEY_H";
|
|
|
- KeyCode[KeyCode["KEY_I"] = 39] = "KEY_I";
|
|
|
- KeyCode[KeyCode["KEY_J"] = 40] = "KEY_J";
|
|
|
- KeyCode[KeyCode["KEY_K"] = 41] = "KEY_K";
|
|
|
- KeyCode[KeyCode["KEY_L"] = 42] = "KEY_L";
|
|
|
- KeyCode[KeyCode["KEY_M"] = 43] = "KEY_M";
|
|
|
- KeyCode[KeyCode["KEY_N"] = 44] = "KEY_N";
|
|
|
- KeyCode[KeyCode["KEY_O"] = 45] = "KEY_O";
|
|
|
- KeyCode[KeyCode["KEY_P"] = 46] = "KEY_P";
|
|
|
- KeyCode[KeyCode["KEY_Q"] = 47] = "KEY_Q";
|
|
|
- KeyCode[KeyCode["KEY_R"] = 48] = "KEY_R";
|
|
|
- KeyCode[KeyCode["KEY_S"] = 49] = "KEY_S";
|
|
|
- KeyCode[KeyCode["KEY_T"] = 50] = "KEY_T";
|
|
|
- KeyCode[KeyCode["KEY_U"] = 51] = "KEY_U";
|
|
|
- KeyCode[KeyCode["KEY_V"] = 52] = "KEY_V";
|
|
|
- KeyCode[KeyCode["KEY_W"] = 53] = "KEY_W";
|
|
|
- KeyCode[KeyCode["KEY_X"] = 54] = "KEY_X";
|
|
|
- KeyCode[KeyCode["KEY_Y"] = 55] = "KEY_Y";
|
|
|
- KeyCode[KeyCode["KEY_Z"] = 56] = "KEY_Z";
|
|
|
- KeyCode[KeyCode["Meta"] = 57] = "Meta";
|
|
|
- KeyCode[KeyCode["ContextMenu"] = 58] = "ContextMenu";
|
|
|
- KeyCode[KeyCode["F1"] = 59] = "F1";
|
|
|
- KeyCode[KeyCode["F2"] = 60] = "F2";
|
|
|
- KeyCode[KeyCode["F3"] = 61] = "F3";
|
|
|
- KeyCode[KeyCode["F4"] = 62] = "F4";
|
|
|
- KeyCode[KeyCode["F5"] = 63] = "F5";
|
|
|
- KeyCode[KeyCode["F6"] = 64] = "F6";
|
|
|
- KeyCode[KeyCode["F7"] = 65] = "F7";
|
|
|
- KeyCode[KeyCode["F8"] = 66] = "F8";
|
|
|
- KeyCode[KeyCode["F9"] = 67] = "F9";
|
|
|
- KeyCode[KeyCode["F10"] = 68] = "F10";
|
|
|
- KeyCode[KeyCode["F11"] = 69] = "F11";
|
|
|
- KeyCode[KeyCode["F12"] = 70] = "F12";
|
|
|
- KeyCode[KeyCode["F13"] = 71] = "F13";
|
|
|
- KeyCode[KeyCode["F14"] = 72] = "F14";
|
|
|
- KeyCode[KeyCode["F15"] = 73] = "F15";
|
|
|
- KeyCode[KeyCode["F16"] = 74] = "F16";
|
|
|
- KeyCode[KeyCode["F17"] = 75] = "F17";
|
|
|
- KeyCode[KeyCode["F18"] = 76] = "F18";
|
|
|
- KeyCode[KeyCode["F19"] = 77] = "F19";
|
|
|
- KeyCode[KeyCode["NumLock"] = 78] = "NumLock";
|
|
|
- KeyCode[KeyCode["ScrollLock"] = 79] = "ScrollLock";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ';:' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_SEMICOLON"] = 80] = "US_SEMICOLON";
|
|
|
- /**
|
|
|
- * For any country/region, the '+' key
|
|
|
- * For the US standard keyboard, the '=+' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_EQUAL"] = 81] = "US_EQUAL";
|
|
|
- /**
|
|
|
- * For any country/region, the ',' key
|
|
|
- * For the US standard keyboard, the ',<' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_COMMA"] = 82] = "US_COMMA";
|
|
|
- /**
|
|
|
- * For any country/region, the '-' key
|
|
|
- * For the US standard keyboard, the '-_' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_MINUS"] = 83] = "US_MINUS";
|
|
|
- /**
|
|
|
- * For any country/region, the '.' key
|
|
|
- * For the US standard keyboard, the '.>' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_DOT"] = 84] = "US_DOT";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '/?' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_SLASH"] = 85] = "US_SLASH";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '`~' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_BACKTICK"] = 86] = "US_BACKTICK";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '[{' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_OPEN_SQUARE_BRACKET"] = 87] = "US_OPEN_SQUARE_BRACKET";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '\|' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_BACKSLASH"] = 88] = "US_BACKSLASH";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ']}' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_CLOSE_SQUARE_BRACKET"] = 89] = "US_CLOSE_SQUARE_BRACKET";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ''"' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_QUOTE"] = 90] = "US_QUOTE";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["OEM_8"] = 91] = "OEM_8";
|
|
|
- /**
|
|
|
- * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["OEM_102"] = 92] = "OEM_102";
|
|
|
- KeyCode[KeyCode["NUMPAD_0"] = 93] = "NUMPAD_0";
|
|
|
- KeyCode[KeyCode["NUMPAD_1"] = 94] = "NUMPAD_1";
|
|
|
- KeyCode[KeyCode["NUMPAD_2"] = 95] = "NUMPAD_2";
|
|
|
- KeyCode[KeyCode["NUMPAD_3"] = 96] = "NUMPAD_3";
|
|
|
- KeyCode[KeyCode["NUMPAD_4"] = 97] = "NUMPAD_4";
|
|
|
- KeyCode[KeyCode["NUMPAD_5"] = 98] = "NUMPAD_5";
|
|
|
- KeyCode[KeyCode["NUMPAD_6"] = 99] = "NUMPAD_6";
|
|
|
- KeyCode[KeyCode["NUMPAD_7"] = 100] = "NUMPAD_7";
|
|
|
- KeyCode[KeyCode["NUMPAD_8"] = 101] = "NUMPAD_8";
|
|
|
- KeyCode[KeyCode["NUMPAD_9"] = 102] = "NUMPAD_9";
|
|
|
- KeyCode[KeyCode["NUMPAD_MULTIPLY"] = 103] = "NUMPAD_MULTIPLY";
|
|
|
- KeyCode[KeyCode["NUMPAD_ADD"] = 104] = "NUMPAD_ADD";
|
|
|
- KeyCode[KeyCode["NUMPAD_SEPARATOR"] = 105] = "NUMPAD_SEPARATOR";
|
|
|
- KeyCode[KeyCode["NUMPAD_SUBTRACT"] = 106] = "NUMPAD_SUBTRACT";
|
|
|
- KeyCode[KeyCode["NUMPAD_DECIMAL"] = 107] = "NUMPAD_DECIMAL";
|
|
|
- KeyCode[KeyCode["NUMPAD_DIVIDE"] = 108] = "NUMPAD_DIVIDE";
|
|
|
- /**
|
|
|
- * Cover all key codes when IME is processing input.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["KEY_IN_COMPOSITION"] = 109] = "KEY_IN_COMPOSITION";
|
|
|
- KeyCode[KeyCode["ABNT_C1"] = 110] = "ABNT_C1";
|
|
|
- KeyCode[KeyCode["ABNT_C2"] = 111] = "ABNT_C2";
|
|
|
- /**
|
|
|
- * Placed last to cover the length of the enum.
|
|
|
- * Please do not depend on this value!
|
|
|
- */
|
|
|
- KeyCode[KeyCode["MAX_VALUE"] = 112] = "MAX_VALUE";
|
|
|
- })(KeyCode = exports.KeyCode || (exports.KeyCode = {}));
|
|
|
- var KeyCodeStrMap = (function () {
|
|
|
- function KeyCodeStrMap() {
|
|
|
- this._keyCodeToStr = [];
|
|
|
- this._strToKeyCode = Object.create(null);
|
|
|
- }
|
|
|
- KeyCodeStrMap.prototype.define = function (keyCode, str) {
|
|
|
- this._keyCodeToStr[keyCode] = str;
|
|
|
- this._strToKeyCode[str.toLowerCase()] = keyCode;
|
|
|
- };
|
|
|
- KeyCodeStrMap.prototype.keyCodeToStr = function (keyCode) {
|
|
|
- return this._keyCodeToStr[keyCode];
|
|
|
- };
|
|
|
- KeyCodeStrMap.prototype.strToKeyCode = function (str) {
|
|
|
- return this._strToKeyCode[str.toLowerCase()] || 0 /* Unknown */;
|
|
|
- };
|
|
|
- return KeyCodeStrMap;
|
|
|
- }());
|
|
|
- var uiMap = new KeyCodeStrMap();
|
|
|
- var userSettingsUSMap = new KeyCodeStrMap();
|
|
|
- var userSettingsGeneralMap = new KeyCodeStrMap();
|
|
|
- (function () {
|
|
|
- function define(keyCode, uiLabel, usUserSettingsLabel, generalUserSettingsLabel) {
|
|
|
- if (usUserSettingsLabel === void 0) { usUserSettingsLabel = uiLabel; }
|
|
|
- if (generalUserSettingsLabel === void 0) { generalUserSettingsLabel = usUserSettingsLabel; }
|
|
|
- uiMap.define(keyCode, uiLabel);
|
|
|
- userSettingsUSMap.define(keyCode, usUserSettingsLabel);
|
|
|
- userSettingsGeneralMap.define(keyCode, generalUserSettingsLabel);
|
|
|
- }
|
|
|
- define(0 /* Unknown */, 'unknown');
|
|
|
- define(1 /* Backspace */, 'Backspace');
|
|
|
- define(2 /* Tab */, 'Tab');
|
|
|
- define(3 /* Enter */, 'Enter');
|
|
|
- define(4 /* Shift */, 'Shift');
|
|
|
- define(5 /* Ctrl */, 'Ctrl');
|
|
|
- define(6 /* Alt */, 'Alt');
|
|
|
- define(7 /* PauseBreak */, 'PauseBreak');
|
|
|
- define(8 /* CapsLock */, 'CapsLock');
|
|
|
- define(9 /* Escape */, 'Escape');
|
|
|
- define(10 /* Space */, 'Space');
|
|
|
- define(11 /* PageUp */, 'PageUp');
|
|
|
- define(12 /* PageDown */, 'PageDown');
|
|
|
- define(13 /* End */, 'End');
|
|
|
- define(14 /* Home */, 'Home');
|
|
|
- define(15 /* LeftArrow */, 'LeftArrow', 'Left');
|
|
|
- define(16 /* UpArrow */, 'UpArrow', 'Up');
|
|
|
- define(17 /* RightArrow */, 'RightArrow', 'Right');
|
|
|
- define(18 /* DownArrow */, 'DownArrow', 'Down');
|
|
|
- define(19 /* Insert */, 'Insert');
|
|
|
- define(20 /* Delete */, 'Delete');
|
|
|
- define(21 /* KEY_0 */, '0');
|
|
|
- define(22 /* KEY_1 */, '1');
|
|
|
- define(23 /* KEY_2 */, '2');
|
|
|
- define(24 /* KEY_3 */, '3');
|
|
|
- define(25 /* KEY_4 */, '4');
|
|
|
- define(26 /* KEY_5 */, '5');
|
|
|
- define(27 /* KEY_6 */, '6');
|
|
|
- define(28 /* KEY_7 */, '7');
|
|
|
- define(29 /* KEY_8 */, '8');
|
|
|
- define(30 /* KEY_9 */, '9');
|
|
|
- define(31 /* KEY_A */, 'A');
|
|
|
- define(32 /* KEY_B */, 'B');
|
|
|
- define(33 /* KEY_C */, 'C');
|
|
|
- define(34 /* KEY_D */, 'D');
|
|
|
- define(35 /* KEY_E */, 'E');
|
|
|
- define(36 /* KEY_F */, 'F');
|
|
|
- define(37 /* KEY_G */, 'G');
|
|
|
- define(38 /* KEY_H */, 'H');
|
|
|
- define(39 /* KEY_I */, 'I');
|
|
|
- define(40 /* KEY_J */, 'J');
|
|
|
- define(41 /* KEY_K */, 'K');
|
|
|
- define(42 /* KEY_L */, 'L');
|
|
|
- define(43 /* KEY_M */, 'M');
|
|
|
- define(44 /* KEY_N */, 'N');
|
|
|
- define(45 /* KEY_O */, 'O');
|
|
|
- define(46 /* KEY_P */, 'P');
|
|
|
- define(47 /* KEY_Q */, 'Q');
|
|
|
- define(48 /* KEY_R */, 'R');
|
|
|
- define(49 /* KEY_S */, 'S');
|
|
|
- define(50 /* KEY_T */, 'T');
|
|
|
- define(51 /* KEY_U */, 'U');
|
|
|
- define(52 /* KEY_V */, 'V');
|
|
|
- define(53 /* KEY_W */, 'W');
|
|
|
- define(54 /* KEY_X */, 'X');
|
|
|
- define(55 /* KEY_Y */, 'Y');
|
|
|
- define(56 /* KEY_Z */, 'Z');
|
|
|
- define(57 /* Meta */, 'Meta');
|
|
|
- define(58 /* ContextMenu */, 'ContextMenu');
|
|
|
- define(59 /* F1 */, 'F1');
|
|
|
- define(60 /* F2 */, 'F2');
|
|
|
- define(61 /* F3 */, 'F3');
|
|
|
- define(62 /* F4 */, 'F4');
|
|
|
- define(63 /* F5 */, 'F5');
|
|
|
- define(64 /* F6 */, 'F6');
|
|
|
- define(65 /* F7 */, 'F7');
|
|
|
- define(66 /* F8 */, 'F8');
|
|
|
- define(67 /* F9 */, 'F9');
|
|
|
- define(68 /* F10 */, 'F10');
|
|
|
- define(69 /* F11 */, 'F11');
|
|
|
- define(70 /* F12 */, 'F12');
|
|
|
- define(71 /* F13 */, 'F13');
|
|
|
- define(72 /* F14 */, 'F14');
|
|
|
- define(73 /* F15 */, 'F15');
|
|
|
- define(74 /* F16 */, 'F16');
|
|
|
- define(75 /* F17 */, 'F17');
|
|
|
- define(76 /* F18 */, 'F18');
|
|
|
- define(77 /* F19 */, 'F19');
|
|
|
- define(78 /* NumLock */, 'NumLock');
|
|
|
- define(79 /* ScrollLock */, 'ScrollLock');
|
|
|
- define(80 /* US_SEMICOLON */, ';', ';', 'OEM_1');
|
|
|
- define(81 /* US_EQUAL */, '=', '=', 'OEM_PLUS');
|
|
|
- define(82 /* US_COMMA */, ',', ',', 'OEM_COMMA');
|
|
|
- define(83 /* US_MINUS */, '-', '-', 'OEM_MINUS');
|
|
|
- define(84 /* US_DOT */, '.', '.', 'OEM_PERIOD');
|
|
|
- define(85 /* US_SLASH */, '/', '/', 'OEM_2');
|
|
|
- define(86 /* US_BACKTICK */, '`', '`', 'OEM_3');
|
|
|
- define(110 /* ABNT_C1 */, 'ABNT_C1');
|
|
|
- define(111 /* ABNT_C2 */, 'ABNT_C2');
|
|
|
- define(87 /* US_OPEN_SQUARE_BRACKET */, '[', '[', 'OEM_4');
|
|
|
- define(88 /* US_BACKSLASH */, '\\', '\\', 'OEM_5');
|
|
|
- define(89 /* US_CLOSE_SQUARE_BRACKET */, ']', ']', 'OEM_6');
|
|
|
- define(90 /* US_QUOTE */, '\'', '\'', 'OEM_7');
|
|
|
- define(91 /* OEM_8 */, 'OEM_8');
|
|
|
- define(92 /* OEM_102 */, 'OEM_102');
|
|
|
- define(93 /* NUMPAD_0 */, 'NumPad0');
|
|
|
- define(94 /* NUMPAD_1 */, 'NumPad1');
|
|
|
- define(95 /* NUMPAD_2 */, 'NumPad2');
|
|
|
- define(96 /* NUMPAD_3 */, 'NumPad3');
|
|
|
- define(97 /* NUMPAD_4 */, 'NumPad4');
|
|
|
- define(98 /* NUMPAD_5 */, 'NumPad5');
|
|
|
- define(99 /* NUMPAD_6 */, 'NumPad6');
|
|
|
- define(100 /* NUMPAD_7 */, 'NumPad7');
|
|
|
- define(101 /* NUMPAD_8 */, 'NumPad8');
|
|
|
- define(102 /* NUMPAD_9 */, 'NumPad9');
|
|
|
- define(103 /* NUMPAD_MULTIPLY */, 'NumPad_Multiply');
|
|
|
- define(104 /* NUMPAD_ADD */, 'NumPad_Add');
|
|
|
- define(105 /* NUMPAD_SEPARATOR */, 'NumPad_Separator');
|
|
|
- define(106 /* NUMPAD_SUBTRACT */, 'NumPad_Subtract');
|
|
|
- define(107 /* NUMPAD_DECIMAL */, 'NumPad_Decimal');
|
|
|
- define(108 /* NUMPAD_DIVIDE */, 'NumPad_Divide');
|
|
|
- })();
|
|
|
- var KeyCodeUtils;
|
|
|
- (function (KeyCodeUtils) {
|
|
|
- function toString(keyCode) {
|
|
|
- return uiMap.keyCodeToStr(keyCode);
|
|
|
- }
|
|
|
- KeyCodeUtils.toString = toString;
|
|
|
- function fromString(key) {
|
|
|
- return uiMap.strToKeyCode(key);
|
|
|
- }
|
|
|
- KeyCodeUtils.fromString = fromString;
|
|
|
- function toUserSettingsUS(keyCode) {
|
|
|
- return userSettingsUSMap.keyCodeToStr(keyCode);
|
|
|
- }
|
|
|
- KeyCodeUtils.toUserSettingsUS = toUserSettingsUS;
|
|
|
- function toUserSettingsGeneral(keyCode) {
|
|
|
- return userSettingsGeneralMap.keyCodeToStr(keyCode);
|
|
|
- }
|
|
|
- KeyCodeUtils.toUserSettingsGeneral = toUserSettingsGeneral;
|
|
|
- function fromUserSettings(key) {
|
|
|
- return userSettingsUSMap.strToKeyCode(key) || userSettingsGeneralMap.strToKeyCode(key);
|
|
|
- }
|
|
|
- KeyCodeUtils.fromUserSettings = fromUserSettings;
|
|
|
- })(KeyCodeUtils = exports.KeyCodeUtils || (exports.KeyCodeUtils = {}));
|
|
|
- /**
|
|
|
- * Binary encoding strategy:
|
|
|
- * ```
|
|
|
- * 1111 11
|
|
|
- * 5432 1098 7654 3210
|
|
|
- * ---- CSAW KKKK KKKK
|
|
|
- * C = bit 11 = ctrlCmd flag
|
|
|
- * S = bit 10 = shift flag
|
|
|
- * A = bit 9 = alt flag
|
|
|
- * W = bit 8 = winCtrl flag
|
|
|
- * K = bits 0-7 = key code
|
|
|
- * ```
|
|
|
- */
|
|
|
- var BinaryKeybindingsMask;
|
|
|
- (function (BinaryKeybindingsMask) {
|
|
|
- BinaryKeybindingsMask[BinaryKeybindingsMask["CtrlCmd"] = 2048] = "CtrlCmd";
|
|
|
- BinaryKeybindingsMask[BinaryKeybindingsMask["Shift"] = 1024] = "Shift";
|
|
|
- BinaryKeybindingsMask[BinaryKeybindingsMask["Alt"] = 512] = "Alt";
|
|
|
- BinaryKeybindingsMask[BinaryKeybindingsMask["WinCtrl"] = 256] = "WinCtrl";
|
|
|
- BinaryKeybindingsMask[BinaryKeybindingsMask["KeyCode"] = 255] = "KeyCode";
|
|
|
- })(BinaryKeybindingsMask || (BinaryKeybindingsMask = {}));
|
|
|
- var KeyMod;
|
|
|
- (function (KeyMod) {
|
|
|
- KeyMod[KeyMod["CtrlCmd"] = 2048] = "CtrlCmd";
|
|
|
- KeyMod[KeyMod["Shift"] = 1024] = "Shift";
|
|
|
- KeyMod[KeyMod["Alt"] = 512] = "Alt";
|
|
|
- KeyMod[KeyMod["WinCtrl"] = 256] = "WinCtrl";
|
|
|
- })(KeyMod = exports.KeyMod || (exports.KeyMod = {}));
|
|
|
- function KeyChord(firstPart, secondPart) {
|
|
|
- var chordPart = ((secondPart & 0x0000ffff) << 16) >>> 0;
|
|
|
- return (firstPart | chordPart) >>> 0;
|
|
|
- }
|
|
|
- exports.KeyChord = KeyChord;
|
|
|
- function createKeybinding(keybinding, OS) {
|
|
|
- if (keybinding === 0) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var firstPart = (keybinding & 0x0000ffff) >>> 0;
|
|
|
- var chordPart = (keybinding & 0xffff0000) >>> 16;
|
|
|
- if (chordPart !== 0) {
|
|
|
- return new ChordKeybinding(createSimpleKeybinding(firstPart, OS), createSimpleKeybinding(chordPart, OS));
|
|
|
- }
|
|
|
- return createSimpleKeybinding(firstPart, OS);
|
|
|
- }
|
|
|
- exports.createKeybinding = createKeybinding;
|
|
|
- function createSimpleKeybinding(keybinding, OS) {
|
|
|
- var ctrlCmd = (keybinding & 2048 /* CtrlCmd */ ? true : false);
|
|
|
- var winCtrl = (keybinding & 256 /* WinCtrl */ ? true : false);
|
|
|
- var ctrlKey = (OS === 2 /* Macintosh */ ? winCtrl : ctrlCmd);
|
|
|
- var shiftKey = (keybinding & 1024 /* Shift */ ? true : false);
|
|
|
- var altKey = (keybinding & 512 /* Alt */ ? true : false);
|
|
|
- var metaKey = (OS === 2 /* Macintosh */ ? ctrlCmd : winCtrl);
|
|
|
- var keyCode = (keybinding & 255 /* KeyCode */);
|
|
|
- return new SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode);
|
|
|
- }
|
|
|
- exports.createSimpleKeybinding = createSimpleKeybinding;
|
|
|
- var KeybindingType;
|
|
|
- (function (KeybindingType) {
|
|
|
- KeybindingType[KeybindingType["Simple"] = 1] = "Simple";
|
|
|
- KeybindingType[KeybindingType["Chord"] = 2] = "Chord";
|
|
|
- })(KeybindingType = exports.KeybindingType || (exports.KeybindingType = {}));
|
|
|
- var SimpleKeybinding = (function () {
|
|
|
- function SimpleKeybinding(ctrlKey, shiftKey, altKey, metaKey, keyCode) {
|
|
|
- this.type = 1 /* Simple */;
|
|
|
- this.ctrlKey = ctrlKey;
|
|
|
- this.shiftKey = shiftKey;
|
|
|
- this.altKey = altKey;
|
|
|
- this.metaKey = metaKey;
|
|
|
- this.keyCode = keyCode;
|
|
|
- }
|
|
|
- SimpleKeybinding.prototype.equals = function (other) {
|
|
|
- if (other.type !== 1 /* Simple */) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return (this.ctrlKey === other.ctrlKey
|
|
|
- && this.shiftKey === other.shiftKey
|
|
|
- && this.altKey === other.altKey
|
|
|
- && this.metaKey === other.metaKey
|
|
|
- && this.keyCode === other.keyCode);
|
|
|
- };
|
|
|
- SimpleKeybinding.prototype.isModifierKey = function () {
|
|
|
- return (this.keyCode === 0 /* Unknown */
|
|
|
- || this.keyCode === 5 /* Ctrl */
|
|
|
- || this.keyCode === 57 /* Meta */
|
|
|
- || this.keyCode === 6 /* Alt */
|
|
|
- || this.keyCode === 4 /* Shift */);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?
|
|
|
- */
|
|
|
- SimpleKeybinding.prototype.isDuplicateModifierCase = function () {
|
|
|
- return ((this.ctrlKey && this.keyCode === 5 /* Ctrl */)
|
|
|
- || (this.shiftKey && this.keyCode === 4 /* Shift */)
|
|
|
- || (this.altKey && this.keyCode === 6 /* Alt */)
|
|
|
- || (this.metaKey && this.keyCode === 57 /* Meta */));
|
|
|
- };
|
|
|
- return SimpleKeybinding;
|
|
|
- }());
|
|
|
- exports.SimpleKeybinding = SimpleKeybinding;
|
|
|
- var ChordKeybinding = (function () {
|
|
|
- function ChordKeybinding(firstPart, chordPart) {
|
|
|
- this.type = 2 /* Chord */;
|
|
|
- this.firstPart = firstPart;
|
|
|
- this.chordPart = chordPart;
|
|
|
- }
|
|
|
- return ChordKeybinding;
|
|
|
- }());
|
|
|
- exports.ChordKeybinding = ChordKeybinding;
|
|
|
- var ResolvedKeybindingPart = (function () {
|
|
|
- function ResolvedKeybindingPart(ctrlKey, shiftKey, altKey, metaKey, kbLabel, kbAriaLabel) {
|
|
|
- this.ctrlKey = ctrlKey;
|
|
|
- this.shiftKey = shiftKey;
|
|
|
- this.altKey = altKey;
|
|
|
- this.metaKey = metaKey;
|
|
|
- this.keyLabel = kbLabel;
|
|
|
- this.keyAriaLabel = kbAriaLabel;
|
|
|
- }
|
|
|
- return ResolvedKeybindingPart;
|
|
|
- }());
|
|
|
- exports.ResolvedKeybindingPart = ResolvedKeybindingPart;
|
|
|
- /**
|
|
|
- * A resolved keybinding. Can be a simple keybinding or a chord keybinding.
|
|
|
- */
|
|
|
- var ResolvedKeybinding = (function () {
|
|
|
- function ResolvedKeybinding() {
|
|
|
- }
|
|
|
- return ResolvedKeybinding;
|
|
|
- }());
|
|
|
- exports.ResolvedKeybinding = ResolvedKeybinding;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-define(__m[10/*vs/base/common/lifecycle*/], __M([1/*require*/,0/*exports*/,11/*vs/base/common/functional*/]), function (require, exports, functional_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- exports.empty = Object.freeze({
|
|
|
- dispose: function () { }
|
|
|
- });
|
|
|
- function dispose(first) {
|
|
|
- var rest = [];
|
|
|
- for (var _i = 1; _i < arguments.length; _i++) {
|
|
|
- rest[_i - 1] = arguments[_i];
|
|
|
- }
|
|
|
- if (Array.isArray(first)) {
|
|
|
- first.forEach(function (d) { return d && d.dispose(); });
|
|
|
- return [];
|
|
|
- }
|
|
|
- else if (rest.length === 0) {
|
|
|
- if (first) {
|
|
|
- first.dispose();
|
|
|
- return first;
|
|
|
- }
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- else {
|
|
|
- dispose(first);
|
|
|
- dispose(rest);
|
|
|
- return [];
|
|
|
- }
|
|
|
- }
|
|
|
- exports.dispose = dispose;
|
|
|
- function combinedDisposable(disposables) {
|
|
|
- return { dispose: function () { return dispose(disposables); } };
|
|
|
- }
|
|
|
- exports.combinedDisposable = combinedDisposable;
|
|
|
- function toDisposable() {
|
|
|
- var fns = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- fns[_i] = arguments[_i];
|
|
|
- }
|
|
|
- return {
|
|
|
- dispose: function () {
|
|
|
- for (var _i = 0, fns_1 = fns; _i < fns_1.length; _i++) {
|
|
|
- var fn = fns_1[_i];
|
|
|
- fn();
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- }
|
|
|
- exports.toDisposable = toDisposable;
|
|
|
- var Disposable = (function () {
|
|
|
- function Disposable() {
|
|
|
- this._toDispose = [];
|
|
|
- }
|
|
|
- Disposable.prototype.dispose = function () {
|
|
|
- this._toDispose = dispose(this._toDispose);
|
|
|
- };
|
|
|
- Disposable.prototype._register = function (t) {
|
|
|
- this._toDispose.push(t);
|
|
|
- return t;
|
|
|
- };
|
|
|
- return Disposable;
|
|
|
- }());
|
|
|
- exports.Disposable = Disposable;
|
|
|
- var OneDisposable = (function () {
|
|
|
- function OneDisposable() {
|
|
|
- }
|
|
|
- Object.defineProperty(OneDisposable.prototype, "value", {
|
|
|
- set: function (value) {
|
|
|
- if (this._value) {
|
|
|
- this._value.dispose();
|
|
|
- }
|
|
|
- this._value = value;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- OneDisposable.prototype.dispose = function () {
|
|
|
- this.value = null;
|
|
|
- };
|
|
|
- return OneDisposable;
|
|
|
- }());
|
|
|
- exports.OneDisposable = OneDisposable;
|
|
|
- var ReferenceCollection = (function () {
|
|
|
- function ReferenceCollection() {
|
|
|
- this.references = Object.create(null);
|
|
|
- }
|
|
|
- ReferenceCollection.prototype.acquire = function (key) {
|
|
|
- var _this = this;
|
|
|
- var reference = this.references[key];
|
|
|
- if (!reference) {
|
|
|
- reference = this.references[key] = { counter: 0, object: this.createReferencedObject(key) };
|
|
|
- }
|
|
|
- var object = reference.object;
|
|
|
- var dispose = functional_1.once(function () {
|
|
|
- if (--reference.counter === 0) {
|
|
|
- _this.destroyReferencedObject(reference.object);
|
|
|
- delete _this.references[key];
|
|
|
- }
|
|
|
- });
|
|
|
- reference.counter++;
|
|
|
- return { object: object, dispose: dispose };
|
|
|
- };
|
|
|
- return ReferenceCollection;
|
|
|
- }());
|
|
|
- exports.ReferenceCollection = ReferenceCollection;
|
|
|
- var ImmortalReference = (function () {
|
|
|
- function ImmortalReference(object) {
|
|
|
- this.object = object;
|
|
|
- }
|
|
|
- ImmortalReference.prototype.dispose = function () { };
|
|
|
- return ImmortalReference;
|
|
|
- }());
|
|
|
- exports.ImmortalReference = ImmortalReference;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[4/*vs/base/common/platform*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- // --- THIS FILE IS TEMPORARY UNTIL ENV.TS IS CLEANED UP. IT CAN SAFELY BE USED IN ALL TARGET EXECUTION ENVIRONMENTS (node & dom) ---
|
|
|
- var _isWindows = false;
|
|
|
- var _isMacintosh = false;
|
|
|
- var _isLinux = false;
|
|
|
- var _isRootUser = false;
|
|
|
- var _isNative = false;
|
|
|
- var _isWeb = false;
|
|
|
- var _locale = undefined;
|
|
|
- var _language = undefined;
|
|
|
- exports.LANGUAGE_DEFAULT = 'en';
|
|
|
- // OS detection
|
|
|
- if (typeof process === 'object') {
|
|
|
- _isWindows = (process.platform === 'win32');
|
|
|
- _isMacintosh = (process.platform === 'darwin');
|
|
|
- _isLinux = (process.platform === 'linux');
|
|
|
- _isRootUser = !_isWindows && (process.getuid() === 0);
|
|
|
- var rawNlsConfig = process.env['VSCODE_NLS_CONFIG'];
|
|
|
- if (rawNlsConfig) {
|
|
|
- try {
|
|
|
- var nlsConfig = JSON.parse(rawNlsConfig);
|
|
|
- var resolved = nlsConfig.availableLanguages['*'];
|
|
|
- _locale = nlsConfig.locale;
|
|
|
- // VSCode's default language is 'en'
|
|
|
- _language = resolved ? resolved : exports.LANGUAGE_DEFAULT;
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- }
|
|
|
- }
|
|
|
- _isNative = true;
|
|
|
- }
|
|
|
- else if (typeof navigator === 'object') {
|
|
|
- var userAgent = navigator.userAgent;
|
|
|
- _isWindows = userAgent.indexOf('Windows') >= 0;
|
|
|
- _isMacintosh = userAgent.indexOf('Macintosh') >= 0;
|
|
|
- _isLinux = userAgent.indexOf('Linux') >= 0;
|
|
|
- _isWeb = true;
|
|
|
- _locale = navigator.language;
|
|
|
- _language = _locale;
|
|
|
- }
|
|
|
- var Platform;
|
|
|
- (function (Platform) {
|
|
|
- Platform[Platform["Web"] = 0] = "Web";
|
|
|
- Platform[Platform["Mac"] = 1] = "Mac";
|
|
|
- Platform[Platform["Linux"] = 2] = "Linux";
|
|
|
- Platform[Platform["Windows"] = 3] = "Windows";
|
|
|
- })(Platform = exports.Platform || (exports.Platform = {}));
|
|
|
- var _platform = Platform.Web;
|
|
|
- if (_isNative) {
|
|
|
- if (_isMacintosh) {
|
|
|
- _platform = Platform.Mac;
|
|
|
- }
|
|
|
- else if (_isWindows) {
|
|
|
- _platform = Platform.Windows;
|
|
|
- }
|
|
|
- else if (_isLinux) {
|
|
|
- _platform = Platform.Linux;
|
|
|
- }
|
|
|
- }
|
|
|
- exports.isWindows = _isWindows;
|
|
|
- exports.isMacintosh = _isMacintosh;
|
|
|
- exports.isLinux = _isLinux;
|
|
|
- exports.isRootUser = _isRootUser;
|
|
|
- exports.isNative = _isNative;
|
|
|
- exports.isWeb = _isWeb;
|
|
|
- exports.platform = _platform;
|
|
|
- /**
|
|
|
- * The language used for the user interface. The format of
|
|
|
- * the string is all lower case (e.g. zh-tw for Traditional
|
|
|
- * Chinese)
|
|
|
- */
|
|
|
- exports.language = _language;
|
|
|
- /**
|
|
|
- * The OS locale or the locale specified by --locale. The format of
|
|
|
- * the string is all lower case (e.g. zh-tw for Traditional
|
|
|
- * Chinese). The UI is not necessarily shown in the provided locale.
|
|
|
- */
|
|
|
- exports.locale = _locale;
|
|
|
- var _globals = (typeof self === 'object' ? self : global);
|
|
|
- exports.globals = _globals;
|
|
|
- function hasWebWorkerSupport() {
|
|
|
- return typeof _globals.Worker !== 'undefined';
|
|
|
- }
|
|
|
- exports.hasWebWorkerSupport = hasWebWorkerSupport;
|
|
|
- exports.setTimeout = _globals.setTimeout.bind(_globals);
|
|
|
- exports.clearTimeout = _globals.clearTimeout.bind(_globals);
|
|
|
- exports.setInterval = _globals.setInterval.bind(_globals);
|
|
|
- exports.clearInterval = _globals.clearInterval.bind(_globals);
|
|
|
- var OperatingSystem;
|
|
|
- (function (OperatingSystem) {
|
|
|
- OperatingSystem[OperatingSystem["Windows"] = 1] = "Windows";
|
|
|
- OperatingSystem[OperatingSystem["Macintosh"] = 2] = "Macintosh";
|
|
|
- OperatingSystem[OperatingSystem["Linux"] = 3] = "Linux";
|
|
|
- })(OperatingSystem = exports.OperatingSystem || (exports.OperatingSystem = {}));
|
|
|
- exports.OS = (_isMacintosh ? 2 /* Macintosh */ : (_isWindows ? 1 /* Windows */ : 3 /* Linux */));
|
|
|
- var AccessibilitySupport;
|
|
|
- (function (AccessibilitySupport) {
|
|
|
- /**
|
|
|
- * This should be the browser case where it is not known if a screen reader is attached or no.
|
|
|
- */
|
|
|
- AccessibilitySupport[AccessibilitySupport["Unknown"] = 0] = "Unknown";
|
|
|
- AccessibilitySupport[AccessibilitySupport["Disabled"] = 1] = "Disabled";
|
|
|
- AccessibilitySupport[AccessibilitySupport["Enabled"] = 2] = "Enabled";
|
|
|
- })(AccessibilitySupport = exports.AccessibilitySupport || (exports.AccessibilitySupport = {}));
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[14/*vs/base/common/types*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var _typeof = {
|
|
|
- number: 'number',
|
|
|
- string: 'string',
|
|
|
- undefined: 'undefined',
|
|
|
- object: 'object',
|
|
|
- function: 'function'
|
|
|
- };
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is a JavaScript Array or not.
|
|
|
- */
|
|
|
- function isArray(array) {
|
|
|
- if (Array.isArray) {
|
|
|
- return Array.isArray(array);
|
|
|
- }
|
|
|
- if (array && typeof (array.length) === _typeof.number && array.constructor === Array) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- exports.isArray = isArray;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is a JavaScript String or not.
|
|
|
- */
|
|
|
- function isString(str) {
|
|
|
- if (typeof (str) === _typeof.string || str instanceof String) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- exports.isString = isString;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
|
|
|
- */
|
|
|
- function isStringArray(value) {
|
|
|
- return isArray(value) && value.every(function (elem) { return isString(elem); });
|
|
|
- }
|
|
|
- exports.isStringArray = isStringArray;
|
|
|
- /**
|
|
|
- *
|
|
|
- * @returns whether the provided parameter is of type `object` but **not**
|
|
|
- * `null`, an `array`, a `regexp`, nor a `date`.
|
|
|
- */
|
|
|
- function isObject(obj) {
|
|
|
- // The method can't do a type cast since there are type (like strings) which
|
|
|
- // are subclasses of any put not positvely matched by the function. Hence type
|
|
|
- // narrowing results in wrong results.
|
|
|
- return typeof obj === _typeof.object
|
|
|
- && obj !== null
|
|
|
- && !Array.isArray(obj)
|
|
|
- && !(obj instanceof RegExp)
|
|
|
- && !(obj instanceof Date);
|
|
|
- }
|
|
|
- exports.isObject = isObject;
|
|
|
- /**
|
|
|
- * In **contrast** to just checking `typeof` this will return `false` for `NaN`.
|
|
|
- * @returns whether the provided parameter is a JavaScript Number or not.
|
|
|
- */
|
|
|
- function isNumber(obj) {
|
|
|
- if ((typeof (obj) === _typeof.number || obj instanceof Number) && !isNaN(obj)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- exports.isNumber = isNumber;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is a JavaScript Boolean or not.
|
|
|
- */
|
|
|
- function isBoolean(obj) {
|
|
|
- return obj === true || obj === false;
|
|
|
- }
|
|
|
- exports.isBoolean = isBoolean;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is undefined.
|
|
|
- */
|
|
|
- function isUndefined(obj) {
|
|
|
- return typeof (obj) === _typeof.undefined;
|
|
|
- }
|
|
|
- exports.isUndefined = isUndefined;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is undefined or null.
|
|
|
- */
|
|
|
- function isUndefinedOrNull(obj) {
|
|
|
- return isUndefined(obj) || obj === null;
|
|
|
- }
|
|
|
- exports.isUndefinedOrNull = isUndefinedOrNull;
|
|
|
- var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is an empty JavaScript Object or not.
|
|
|
- */
|
|
|
- function isEmptyObject(obj) {
|
|
|
- if (!isObject(obj)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var key in obj) {
|
|
|
- if (hasOwnProperty.call(obj, key)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- exports.isEmptyObject = isEmptyObject;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameter is a JavaScript Function or not.
|
|
|
- */
|
|
|
- function isFunction(obj) {
|
|
|
- return typeof obj === _typeof.function;
|
|
|
- }
|
|
|
- exports.isFunction = isFunction;
|
|
|
- /**
|
|
|
- * @returns whether the provided parameters is are JavaScript Function or not.
|
|
|
- */
|
|
|
- function areFunctions() {
|
|
|
- var objects = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- objects[_i] = arguments[_i];
|
|
|
- }
|
|
|
- return objects && objects.length > 0 && objects.every(isFunction);
|
|
|
- }
|
|
|
- exports.areFunctions = areFunctions;
|
|
|
- function validateConstraints(args, constraints) {
|
|
|
- var len = Math.min(args.length, constraints.length);
|
|
|
- for (var i = 0; i < len; i++) {
|
|
|
- validateConstraint(args[i], constraints[i]);
|
|
|
- }
|
|
|
- }
|
|
|
- exports.validateConstraints = validateConstraints;
|
|
|
- function validateConstraint(arg, constraint) {
|
|
|
- if (isString(constraint)) {
|
|
|
- if (typeof arg !== constraint) {
|
|
|
- throw new Error("argument does not match constraint: typeof " + constraint);
|
|
|
- }
|
|
|
- }
|
|
|
- else if (isFunction(constraint)) {
|
|
|
- if (arg instanceof constraint) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (arg && arg.constructor === constraint) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
|
|
|
- return;
|
|
|
- }
|
|
|
- throw new Error("argument does not match one of these constraints: arg instanceof constraint, arg.constructor === constraint, nor constraint(arg) === true");
|
|
|
- }
|
|
|
- }
|
|
|
- exports.validateConstraint = validateConstraint;
|
|
|
- /**
|
|
|
- * Creates a new object of the provided class and will call the constructor with
|
|
|
- * any additional argument supplied.
|
|
|
- */
|
|
|
- function create(ctor) {
|
|
|
- var args = [];
|
|
|
- for (var _i = 1; _i < arguments.length; _i++) {
|
|
|
- args[_i - 1] = arguments[_i];
|
|
|
- }
|
|
|
- var obj = Object.create(ctor.prototype);
|
|
|
- ctor.apply(obj, args);
|
|
|
- return obj;
|
|
|
- }
|
|
|
- exports.create = create;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[6/*vs/base/common/uri*/], __M([1/*require*/,0/*exports*/,4/*vs/base/common/platform*/]), function (require, exports, platform) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- function _encode(ch) {
|
|
|
- return '%' + ch.charCodeAt(0).toString(16).toUpperCase();
|
|
|
- }
|
|
|
- // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
|
|
|
- function encodeURIComponent2(str) {
|
|
|
- return encodeURIComponent(str).replace(/[!'()*]/g, _encode);
|
|
|
- }
|
|
|
- function encodeNoop(str) {
|
|
|
- return str.replace(/[#?]/, _encode);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
|
|
|
- * This class is a simple parser which creates the basic component paths
|
|
|
- * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
|
|
|
- * and encoding.
|
|
|
- *
|
|
|
- * foo://example.com:8042/over/there?name=ferret#nose
|
|
|
- * \_/ \______________/\_________/ \_________/ \__/
|
|
|
- * | | | | |
|
|
|
- * scheme authority path query fragment
|
|
|
- * | _____________________|__
|
|
|
- * / \ / \
|
|
|
- * urn:example:animal:ferret:nose
|
|
|
- *
|
|
|
- *
|
|
|
- */
|
|
|
- var URI = (function () {
|
|
|
- function URI() {
|
|
|
- this._scheme = URI._empty;
|
|
|
- this._authority = URI._empty;
|
|
|
- this._path = URI._empty;
|
|
|
- this._query = URI._empty;
|
|
|
- this._fragment = URI._empty;
|
|
|
- this._formatted = null;
|
|
|
- this._fsPath = null;
|
|
|
- }
|
|
|
- URI.isUri = function (thing) {
|
|
|
- if (thing instanceof URI) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (!thing) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return typeof thing.authority === 'string'
|
|
|
- && typeof thing.fragment === 'string'
|
|
|
- && typeof thing.path === 'string'
|
|
|
- && typeof thing.query === 'string'
|
|
|
- && typeof thing.scheme === 'string';
|
|
|
- };
|
|
|
- Object.defineProperty(URI.prototype, "scheme", {
|
|
|
- /**
|
|
|
- * scheme is the 'http' part of 'http://www.msft.com/some/path?query#fragment'.
|
|
|
- * The part before the first colon.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- return this._scheme;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(URI.prototype, "authority", {
|
|
|
- /**
|
|
|
- * authority is the 'www.msft.com' part of 'http://www.msft.com/some/path?query#fragment'.
|
|
|
- * The part between the first double slashes and the next slash.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- return this._authority;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(URI.prototype, "path", {
|
|
|
- /**
|
|
|
- * path is the '/some/path' part of 'http://www.msft.com/some/path?query#fragment'.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- return this._path;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(URI.prototype, "query", {
|
|
|
- /**
|
|
|
- * query is the 'query' part of 'http://www.msft.com/some/path?query#fragment'.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- return this._query;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(URI.prototype, "fragment", {
|
|
|
- /**
|
|
|
- * fragment is the 'fragment' part of 'http://www.msft.com/some/path?query#fragment'.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- return this._fragment;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(URI.prototype, "fsPath", {
|
|
|
- // ---- filesystem path -----------------------
|
|
|
- /**
|
|
|
- * Returns a string representing the corresponding file system path of this URI.
|
|
|
- * Will handle UNC paths and normalize windows drive letters to lower-case. Also
|
|
|
- * uses the platform specific path separator. Will *not* validate the path for
|
|
|
- * invalid characters and semantics. Will *not* look at the scheme of this URI.
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- if (!this._fsPath) {
|
|
|
- var value;
|
|
|
- if (this._authority && this._path && this.scheme === 'file') {
|
|
|
- // unc path: file://shares/c$/far/boo
|
|
|
- value = "//" + this._authority + this._path;
|
|
|
- }
|
|
|
- else if (URI._driveLetterPath.test(this._path)) {
|
|
|
- // windows drive letter: file:///c:/far/boo
|
|
|
- value = this._path[1].toLowerCase() + this._path.substr(2);
|
|
|
- }
|
|
|
- else {
|
|
|
- // other path
|
|
|
- value = this._path;
|
|
|
- }
|
|
|
- if (platform.isWindows) {
|
|
|
- value = value.replace(/\//g, '\\');
|
|
|
- }
|
|
|
- this._fsPath = value;
|
|
|
- }
|
|
|
- return this._fsPath;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- // ---- modify to new -------------------------
|
|
|
- URI.prototype.with = function (change) {
|
|
|
- if (!change) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- var scheme = change.scheme, authority = change.authority, path = change.path, query = change.query, fragment = change.fragment;
|
|
|
- if (scheme === void 0) {
|
|
|
- scheme = this.scheme;
|
|
|
- }
|
|
|
- else if (scheme === null) {
|
|
|
- scheme = '';
|
|
|
- }
|
|
|
- if (authority === void 0) {
|
|
|
- authority = this.authority;
|
|
|
- }
|
|
|
- else if (authority === null) {
|
|
|
- authority = '';
|
|
|
- }
|
|
|
- if (path === void 0) {
|
|
|
- path = this.path;
|
|
|
- }
|
|
|
- else if (path === null) {
|
|
|
- path = '';
|
|
|
- }
|
|
|
- if (query === void 0) {
|
|
|
- query = this.query;
|
|
|
- }
|
|
|
- else if (query === null) {
|
|
|
- query = '';
|
|
|
- }
|
|
|
- if (fragment === void 0) {
|
|
|
- fragment = this.fragment;
|
|
|
- }
|
|
|
- else if (fragment === null) {
|
|
|
- fragment = '';
|
|
|
- }
|
|
|
- if (scheme === this.scheme
|
|
|
- && authority === this.authority
|
|
|
- && path === this.path
|
|
|
- && query === this.query
|
|
|
- && fragment === this.fragment) {
|
|
|
- return this;
|
|
|
- }
|
|
|
- var ret = new URI();
|
|
|
- ret._scheme = scheme;
|
|
|
- ret._authority = authority;
|
|
|
- ret._path = path;
|
|
|
- ret._query = query;
|
|
|
- ret._fragment = fragment;
|
|
|
- URI._validate(ret);
|
|
|
- return ret;
|
|
|
- };
|
|
|
- // ---- parse & validate ------------------------
|
|
|
- URI.parse = function (value) {
|
|
|
- var ret = new URI();
|
|
|
- var data = URI._parseComponents(value);
|
|
|
- ret._scheme = data.scheme;
|
|
|
- ret._authority = decodeURIComponent(data.authority);
|
|
|
- ret._path = decodeURIComponent(data.path);
|
|
|
- ret._query = decodeURIComponent(data.query);
|
|
|
- ret._fragment = decodeURIComponent(data.fragment);
|
|
|
- URI._validate(ret);
|
|
|
- return ret;
|
|
|
- };
|
|
|
- URI.file = function (path) {
|
|
|
- var ret = new URI();
|
|
|
- ret._scheme = 'file';
|
|
|
- // normalize to fwd-slashes on windows,
|
|
|
- // on other systems bwd-slaches are valid
|
|
|
- // filename character, eg /f\oo/ba\r.txt
|
|
|
- if (platform.isWindows) {
|
|
|
- path = path.replace(/\\/g, URI._slash);
|
|
|
- }
|
|
|
- // check for authority as used in UNC shares
|
|
|
- // or use the path as given
|
|
|
- if (path[0] === URI._slash && path[0] === path[1]) {
|
|
|
- var idx = path.indexOf(URI._slash, 2);
|
|
|
- if (idx === -1) {
|
|
|
- ret._authority = path.substring(2);
|
|
|
- }
|
|
|
- else {
|
|
|
- ret._authority = path.substring(2, idx);
|
|
|
- ret._path = path.substring(idx);
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- ret._path = path;
|
|
|
- }
|
|
|
- // Ensure that path starts with a slash
|
|
|
- // or that it is at least a slash
|
|
|
- if (ret._path[0] !== URI._slash) {
|
|
|
- ret._path = URI._slash + ret._path;
|
|
|
- }
|
|
|
- URI._validate(ret);
|
|
|
- return ret;
|
|
|
- };
|
|
|
- URI._parseComponents = function (value) {
|
|
|
- var ret = {
|
|
|
- scheme: URI._empty,
|
|
|
- authority: URI._empty,
|
|
|
- path: URI._empty,
|
|
|
- query: URI._empty,
|
|
|
- fragment: URI._empty,
|
|
|
- };
|
|
|
- var match = URI._regexp.exec(value);
|
|
|
- if (match) {
|
|
|
- ret.scheme = match[2] || ret.scheme;
|
|
|
- ret.authority = match[4] || ret.authority;
|
|
|
- ret.path = match[5] || ret.path;
|
|
|
- ret.query = match[7] || ret.query;
|
|
|
- ret.fragment = match[9] || ret.fragment;
|
|
|
- }
|
|
|
- return ret;
|
|
|
- };
|
|
|
- URI.from = function (components) {
|
|
|
- return new URI().with(components);
|
|
|
- };
|
|
|
- URI._validate = function (ret) {
|
|
|
- // scheme, https://tools.ietf.org/html/rfc3986#section-3.1
|
|
|
- // ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
|
|
|
- if (ret.scheme && !URI._schemePattern.test(ret.scheme)) {
|
|
|
- throw new Error('[UriError]: Scheme contains illegal characters.');
|
|
|
- }
|
|
|
- // path, http://tools.ietf.org/html/rfc3986#section-3.3
|
|
|
- // If a URI contains an authority component, then the path component
|
|
|
- // must either be empty or begin with a slash ("/") character. If a URI
|
|
|
- // does not contain an authority component, then the path cannot begin
|
|
|
- // with two slash characters ("//").
|
|
|
- if (ret.path) {
|
|
|
- if (ret.authority) {
|
|
|
- if (!URI._singleSlashStart.test(ret.path)) {
|
|
|
- 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');
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- if (URI._doubleSlashStart.test(ret.path)) {
|
|
|
- throw new Error('[UriError]: If a URI does not contain an authority component, then the path cannot begin with two slash characters ("//")');
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- // ---- printing/externalize ---------------------------
|
|
|
- /**
|
|
|
- *
|
|
|
- * @param skipEncoding Do not encode the result, default is `false`
|
|
|
- */
|
|
|
- URI.prototype.toString = function (skipEncoding) {
|
|
|
- if (skipEncoding === void 0) { skipEncoding = false; }
|
|
|
- if (!skipEncoding) {
|
|
|
- if (!this._formatted) {
|
|
|
- this._formatted = URI._asFormatted(this, false);
|
|
|
- }
|
|
|
- return this._formatted;
|
|
|
- }
|
|
|
- else {
|
|
|
- // we don't cache that
|
|
|
- return URI._asFormatted(this, true);
|
|
|
- }
|
|
|
- };
|
|
|
- URI._asFormatted = function (uri, skipEncoding) {
|
|
|
- var encoder = !skipEncoding
|
|
|
- ? encodeURIComponent2
|
|
|
- : encodeNoop;
|
|
|
- var parts = [];
|
|
|
- var scheme = uri.scheme, authority = uri.authority, path = uri.path, query = uri.query, fragment = uri.fragment;
|
|
|
- if (scheme) {
|
|
|
- parts.push(scheme, ':');
|
|
|
- }
|
|
|
- if (authority || scheme === 'file') {
|
|
|
- parts.push('//');
|
|
|
- }
|
|
|
- if (authority) {
|
|
|
- authority = authority.toLowerCase();
|
|
|
- var idx = authority.indexOf(':');
|
|
|
- if (idx === -1) {
|
|
|
- parts.push(encoder(authority));
|
|
|
- }
|
|
|
- else {
|
|
|
- parts.push(encoder(authority.substr(0, idx)), authority.substr(idx));
|
|
|
- }
|
|
|
- }
|
|
|
- if (path) {
|
|
|
- // lower-case windows drive letters in /C:/fff or C:/fff
|
|
|
- var m = URI._upperCaseDrive.exec(path);
|
|
|
- if (m) {
|
|
|
- if (m[1]) {
|
|
|
- path = '/' + m[2].toLowerCase() + path.substr(3); // "/c:".length === 3
|
|
|
- }
|
|
|
- else {
|
|
|
- path = m[2].toLowerCase() + path.substr(2); // // "c:".length === 2
|
|
|
- }
|
|
|
- }
|
|
|
- // encode every segement but not slashes
|
|
|
- // make sure that # and ? are always encoded
|
|
|
- // when occurring in paths - otherwise the result
|
|
|
- // cannot be parsed back again
|
|
|
- var lastIdx = 0;
|
|
|
- while (true) {
|
|
|
- var idx = path.indexOf(URI._slash, lastIdx);
|
|
|
- if (idx === -1) {
|
|
|
- parts.push(encoder(path.substring(lastIdx)));
|
|
|
- break;
|
|
|
- }
|
|
|
- parts.push(encoder(path.substring(lastIdx, idx)), URI._slash);
|
|
|
- lastIdx = idx + 1;
|
|
|
- }
|
|
|
- ;
|
|
|
- }
|
|
|
- if (query) {
|
|
|
- parts.push('?', encoder(query));
|
|
|
- }
|
|
|
- if (fragment) {
|
|
|
- parts.push('#', encoder(fragment));
|
|
|
- }
|
|
|
- return parts.join(URI._empty);
|
|
|
- };
|
|
|
- URI.prototype.toJSON = function () {
|
|
|
- var res = {
|
|
|
- fsPath: this.fsPath,
|
|
|
- external: this.toString(),
|
|
|
- $mid: 1
|
|
|
- };
|
|
|
- if (this.path) {
|
|
|
- res.path = this.path;
|
|
|
- }
|
|
|
- if (this.scheme) {
|
|
|
- res.scheme = this.scheme;
|
|
|
- }
|
|
|
- if (this.authority) {
|
|
|
- res.authority = this.authority;
|
|
|
- }
|
|
|
- if (this.query) {
|
|
|
- res.query = this.query;
|
|
|
- }
|
|
|
- if (this.fragment) {
|
|
|
- res.fragment = this.fragment;
|
|
|
- }
|
|
|
- return res;
|
|
|
- };
|
|
|
- URI.revive = function (data) {
|
|
|
- var result = new URI();
|
|
|
- result._scheme = data.scheme || URI._empty;
|
|
|
- result._authority = data.authority || URI._empty;
|
|
|
- result._path = data.path || URI._empty;
|
|
|
- result._query = data.query || URI._empty;
|
|
|
- result._fragment = data.fragment || URI._empty;
|
|
|
- result._fsPath = data.fsPath;
|
|
|
- result._formatted = data.external;
|
|
|
- URI._validate(result);
|
|
|
- return result;
|
|
|
- };
|
|
|
- return URI;
|
|
|
- }());
|
|
|
- URI._empty = '';
|
|
|
- URI._slash = '/';
|
|
|
- URI._regexp = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
|
|
|
- URI._driveLetterPath = /^\/[a-zA-z]:/;
|
|
|
- URI._upperCaseDrive = /^(\/)?([A-Z]:)/;
|
|
|
- URI._schemePattern = /^\w[\w\d+.-]*$/;
|
|
|
- URI._singleSlashStart = /^\//;
|
|
|
- URI._doubleSlashStart = /^\/\//;
|
|
|
- exports.default = URI;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-var __extends = (this && this.__extends) || (function () {
|
|
|
- var extendStatics = Object.setPrototypeOf ||
|
|
|
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
|
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
|
|
- return function (d, b) {
|
|
|
- extendStatics(d, b);
|
|
|
- function __() { this.constructor = d; }
|
|
|
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
|
- };
|
|
|
-})();
|
|
|
-define(__m[17/*vs/base/common/map*/], __M([1/*require*/,0/*exports*/,6/*vs/base/common/uri*/]), function (require, exports, uri_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- function values(map) {
|
|
|
- var result = [];
|
|
|
- map.forEach(function (value) { return result.push(value); });
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.values = values;
|
|
|
- function keys(map) {
|
|
|
- var result = [];
|
|
|
- map.forEach(function (value, key) { return result.push(key); });
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.keys = keys;
|
|
|
- function getOrSet(map, key, value) {
|
|
|
- var result = map.get(key);
|
|
|
- if (result === void 0) {
|
|
|
- result = value;
|
|
|
- map.set(key, result);
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.getOrSet = getOrSet;
|
|
|
- /**
|
|
|
- * A simple Map<T> that optionally allows to set a limit of entries to store. Once the limit is hit,
|
|
|
- * the cache will remove the entry that was last recently added. Or, if a ratio is provided below 1,
|
|
|
- * all elements will be removed until the ratio is full filled (e.g. 0.75 to remove 25% of old elements).
|
|
|
- */
|
|
|
- var BoundedMap = (function () {
|
|
|
- function BoundedMap(limit, ratio, value) {
|
|
|
- if (limit === void 0) { limit = Number.MAX_VALUE; }
|
|
|
- if (ratio === void 0) { ratio = 1; }
|
|
|
- var _this = this;
|
|
|
- this.limit = limit;
|
|
|
- this.map = new Map();
|
|
|
- this.ratio = limit * ratio;
|
|
|
- if (value) {
|
|
|
- value.entries.forEach(function (entry) {
|
|
|
- _this.set(entry.key, entry.value);
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- BoundedMap.prototype.setLimit = function (limit) {
|
|
|
- if (limit < 0) {
|
|
|
- return; // invalid limit
|
|
|
- }
|
|
|
- this.limit = limit;
|
|
|
- while (this.map.size > this.limit) {
|
|
|
- this.trim();
|
|
|
- }
|
|
|
- };
|
|
|
- BoundedMap.prototype.serialize = function () {
|
|
|
- var serialized = { entries: [] };
|
|
|
- this.map.forEach(function (entry) {
|
|
|
- serialized.entries.push({ key: entry.key, value: entry.value });
|
|
|
- });
|
|
|
- return serialized;
|
|
|
- };
|
|
|
- Object.defineProperty(BoundedMap.prototype, "size", {
|
|
|
- get: function () {
|
|
|
- return this.map.size;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- BoundedMap.prototype.set = function (key, value) {
|
|
|
- if (this.map.has(key)) {
|
|
|
- return false; // already present!
|
|
|
- }
|
|
|
- var entry = { key: key, value: value };
|
|
|
- this.push(entry);
|
|
|
- if (this.size > this.limit) {
|
|
|
- this.trim();
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- BoundedMap.prototype.get = function (key) {
|
|
|
- var entry = this.map.get(key);
|
|
|
- return entry ? entry.value : null;
|
|
|
- };
|
|
|
- BoundedMap.prototype.getOrSet = function (k, t) {
|
|
|
- var res = this.get(k);
|
|
|
- if (res) {
|
|
|
- return res;
|
|
|
- }
|
|
|
- this.set(k, t);
|
|
|
- return t;
|
|
|
- };
|
|
|
- BoundedMap.prototype.delete = function (key) {
|
|
|
- var entry = this.map.get(key);
|
|
|
- if (entry) {
|
|
|
- this.map.delete(key);
|
|
|
- if (entry.next) {
|
|
|
- entry.next.prev = entry.prev; // [A]<-[x]<-[C] = [A]<-[C]
|
|
|
- }
|
|
|
- else {
|
|
|
- this.head = entry.prev; // [A]-[x] = [A]
|
|
|
- }
|
|
|
- if (entry.prev) {
|
|
|
- entry.prev.next = entry.next; // [A]->[x]->[C] = [A]->[C]
|
|
|
- }
|
|
|
- else {
|
|
|
- this.tail = entry.next; // [x]-[A] = [A]
|
|
|
- }
|
|
|
- return entry.value;
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- BoundedMap.prototype.has = function (key) {
|
|
|
- return this.map.has(key);
|
|
|
- };
|
|
|
- BoundedMap.prototype.clear = function () {
|
|
|
- this.map.clear();
|
|
|
- this.head = null;
|
|
|
- this.tail = null;
|
|
|
- };
|
|
|
- BoundedMap.prototype.push = function (entry) {
|
|
|
- if (this.head) {
|
|
|
- // [A]-[B] = [A]-[B]->[X]
|
|
|
- entry.prev = this.head;
|
|
|
- this.head.next = entry;
|
|
|
- }
|
|
|
- if (!this.tail) {
|
|
|
- this.tail = entry;
|
|
|
- }
|
|
|
- this.head = entry;
|
|
|
- this.map.set(entry.key, entry);
|
|
|
- };
|
|
|
- BoundedMap.prototype.trim = function () {
|
|
|
- if (this.tail) {
|
|
|
- // Remove all elements until ratio is reached
|
|
|
- if (this.ratio < this.limit) {
|
|
|
- var index = 0;
|
|
|
- var current = this.tail;
|
|
|
- while (current.next) {
|
|
|
- // Remove the entry
|
|
|
- this.map.delete(current.key);
|
|
|
- // if we reached the element that overflows our ratio condition
|
|
|
- // make its next element the new tail of the Map and adjust the size
|
|
|
- if (index === this.ratio) {
|
|
|
- this.tail = current.next;
|
|
|
- this.tail.prev = null;
|
|
|
- break;
|
|
|
- }
|
|
|
- // Move on
|
|
|
- current = current.next;
|
|
|
- index++;
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- this.map.delete(this.tail.key);
|
|
|
- // [x]-[B] = [B]
|
|
|
- this.tail = this.tail.next;
|
|
|
- if (this.tail) {
|
|
|
- this.tail.prev = null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- return BoundedMap;
|
|
|
- }());
|
|
|
- exports.BoundedMap = BoundedMap;
|
|
|
- // --- trie'ish datastructure
|
|
|
- var Node = (function () {
|
|
|
- function Node() {
|
|
|
- this.children = new Map();
|
|
|
- }
|
|
|
- return Node;
|
|
|
- }());
|
|
|
- /**
|
|
|
- * A trie map that allows for fast look up when keys are substrings
|
|
|
- * to the actual search keys (dir/subdir-problem).
|
|
|
- */
|
|
|
- var TrieMap = (function () {
|
|
|
- function TrieMap(splitter) {
|
|
|
- this._root = new Node();
|
|
|
- this._splitter = splitter;
|
|
|
- }
|
|
|
- TrieMap.prototype.insert = function (path, element) {
|
|
|
- var parts = this._splitter(path);
|
|
|
- var i = 0;
|
|
|
- // find insertion node
|
|
|
- var node = this._root;
|
|
|
- for (; i < parts.length; i++) {
|
|
|
- var child = node.children.get(parts[i]);
|
|
|
- if (child) {
|
|
|
- node = child;
|
|
|
- continue;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- // create new nodes
|
|
|
- var newNode;
|
|
|
- for (; i < parts.length; i++) {
|
|
|
- newNode = new Node();
|
|
|
- node.children.set(parts[i], newNode);
|
|
|
- node = newNode;
|
|
|
- }
|
|
|
- node.element = element;
|
|
|
- };
|
|
|
- TrieMap.prototype.lookUp = function (path) {
|
|
|
- var parts = this._splitter(path);
|
|
|
- var children = this._root.children;
|
|
|
- var node;
|
|
|
- for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
|
|
|
- var part = parts_1[_i];
|
|
|
- node = children.get(part);
|
|
|
- if (!node) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- children = node.children;
|
|
|
- }
|
|
|
- return node.element;
|
|
|
- };
|
|
|
- TrieMap.prototype.findSubstr = function (path) {
|
|
|
- var parts = this._splitter(path);
|
|
|
- var lastNode;
|
|
|
- var children = this._root.children;
|
|
|
- for (var _i = 0, parts_2 = parts; _i < parts_2.length; _i++) {
|
|
|
- var part = parts_2[_i];
|
|
|
- var node = children.get(part);
|
|
|
- if (!node) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (node.element) {
|
|
|
- lastNode = node;
|
|
|
- }
|
|
|
- children = node.children;
|
|
|
- }
|
|
|
- // return the last matching node
|
|
|
- // that had an element
|
|
|
- if (lastNode) {
|
|
|
- return lastNode.element;
|
|
|
- }
|
|
|
- return undefined;
|
|
|
- };
|
|
|
- TrieMap.prototype.findSuperstr = function (path) {
|
|
|
- var parts = this._splitter(path);
|
|
|
- var children = this._root.children;
|
|
|
- var node;
|
|
|
- for (var _i = 0, parts_3 = parts; _i < parts_3.length; _i++) {
|
|
|
- var part = parts_3[_i];
|
|
|
- node = children.get(part);
|
|
|
- if (!node) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- children = node.children;
|
|
|
- }
|
|
|
- var result = new TrieMap(this._splitter);
|
|
|
- result._root = node;
|
|
|
- return result;
|
|
|
- };
|
|
|
- return TrieMap;
|
|
|
- }());
|
|
|
- TrieMap.PathSplitter = function (s) { return s.split(/[\\/]/).filter(function (s) { return !!s; }); };
|
|
|
- exports.TrieMap = TrieMap;
|
|
|
- var ResourceMap = (function () {
|
|
|
- function ResourceMap(ignoreCase) {
|
|
|
- this.ignoreCase = ignoreCase;
|
|
|
- this.map = new Map();
|
|
|
- }
|
|
|
- ResourceMap.prototype.set = function (resource, value) {
|
|
|
- this.map.set(this.toKey(resource), value);
|
|
|
- };
|
|
|
- ResourceMap.prototype.get = function (resource) {
|
|
|
- return this.map.get(this.toKey(resource));
|
|
|
- };
|
|
|
- ResourceMap.prototype.has = function (resource) {
|
|
|
- return this.map.has(this.toKey(resource));
|
|
|
- };
|
|
|
- Object.defineProperty(ResourceMap.prototype, "size", {
|
|
|
- get: function () {
|
|
|
- return this.map.size;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- ResourceMap.prototype.clear = function () {
|
|
|
- this.map.clear();
|
|
|
- };
|
|
|
- ResourceMap.prototype.delete = function (resource) {
|
|
|
- return this.map.delete(this.toKey(resource));
|
|
|
- };
|
|
|
- ResourceMap.prototype.forEach = function (clb) {
|
|
|
- this.map.forEach(clb);
|
|
|
- };
|
|
|
- ResourceMap.prototype.values = function () {
|
|
|
- return values(this.map);
|
|
|
- };
|
|
|
- ResourceMap.prototype.toKey = function (resource) {
|
|
|
- var key = resource.toString();
|
|
|
- if (this.ignoreCase) {
|
|
|
- key = key.toLowerCase();
|
|
|
- }
|
|
|
- return key;
|
|
|
- };
|
|
|
- return ResourceMap;
|
|
|
- }());
|
|
|
- exports.ResourceMap = ResourceMap;
|
|
|
- var StrictResourceMap = (function (_super) {
|
|
|
- __extends(StrictResourceMap, _super);
|
|
|
- function StrictResourceMap() {
|
|
|
- return _super.call(this) || this;
|
|
|
- }
|
|
|
- StrictResourceMap.prototype.keys = function () {
|
|
|
- return keys(this.map).map(function (key) { return uri_1.default.parse(key); });
|
|
|
- };
|
|
|
- return StrictResourceMap;
|
|
|
- }(ResourceMap));
|
|
|
- exports.StrictResourceMap = StrictResourceMap;
|
|
|
- var Touch;
|
|
|
- (function (Touch) {
|
|
|
- Touch.None = 0;
|
|
|
- Touch.First = 1;
|
|
|
- Touch.Last = 2;
|
|
|
- })(Touch = exports.Touch || (exports.Touch = {}));
|
|
|
- var LinkedMap = (function () {
|
|
|
- function LinkedMap() {
|
|
|
- this._map = new Map();
|
|
|
- this._head = undefined;
|
|
|
- this._tail = undefined;
|
|
|
- this._size = 0;
|
|
|
- }
|
|
|
- LinkedMap.prototype.clear = function () {
|
|
|
- this._map.clear();
|
|
|
- this._head = undefined;
|
|
|
- this._tail = undefined;
|
|
|
- this._size = 0;
|
|
|
- };
|
|
|
- LinkedMap.prototype.isEmpty = function () {
|
|
|
- return !this._head && !this._tail;
|
|
|
- };
|
|
|
- Object.defineProperty(LinkedMap.prototype, "size", {
|
|
|
- get: function () {
|
|
|
- return this._size;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- LinkedMap.prototype.has = function (key) {
|
|
|
- return this._map.has(key);
|
|
|
- };
|
|
|
- LinkedMap.prototype.get = function (key) {
|
|
|
- var item = this._map.get(key);
|
|
|
- if (!item) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- return item.value;
|
|
|
- };
|
|
|
- LinkedMap.prototype.set = function (key, value, touch) {
|
|
|
- if (touch === void 0) { touch = Touch.None; }
|
|
|
- var item = this._map.get(key);
|
|
|
- if (item) {
|
|
|
- item.value = value;
|
|
|
- if (touch !== Touch.None) {
|
|
|
- this.touch(item, touch);
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- item = { key: key, value: value, next: undefined, previous: undefined };
|
|
|
- switch (touch) {
|
|
|
- case Touch.None:
|
|
|
- this.addItemLast(item);
|
|
|
- break;
|
|
|
- case Touch.First:
|
|
|
- this.addItemFirst(item);
|
|
|
- break;
|
|
|
- case Touch.Last:
|
|
|
- this.addItemLast(item);
|
|
|
- break;
|
|
|
- default:
|
|
|
- this.addItemLast(item);
|
|
|
- break;
|
|
|
- }
|
|
|
- this._map.set(key, item);
|
|
|
- this._size++;
|
|
|
- }
|
|
|
- };
|
|
|
- LinkedMap.prototype.delete = function (key) {
|
|
|
- return !!this.remove(key);
|
|
|
- };
|
|
|
- LinkedMap.prototype.remove = function (key) {
|
|
|
- var item = this._map.get(key);
|
|
|
- if (!item) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- this._map.delete(key);
|
|
|
- this.removeItem(item);
|
|
|
- this._size--;
|
|
|
- return item.value;
|
|
|
- };
|
|
|
- LinkedMap.prototype.shift = function () {
|
|
|
- if (!this._head && !this._tail) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- if (!this._head || !this._tail) {
|
|
|
- throw new Error('Invalid list');
|
|
|
- }
|
|
|
- var item = this._head;
|
|
|
- this._map.delete(item.key);
|
|
|
- this.removeItem(item);
|
|
|
- this._size--;
|
|
|
- return item.value;
|
|
|
- };
|
|
|
- LinkedMap.prototype.forEach = function (callbackfn, thisArg) {
|
|
|
- var current = this._head;
|
|
|
- while (current) {
|
|
|
- if (thisArg) {
|
|
|
- callbackfn.bind(thisArg)(current.value, current.key, this);
|
|
|
- }
|
|
|
- else {
|
|
|
- callbackfn(current.value, current.key, this);
|
|
|
- }
|
|
|
- current = current.next;
|
|
|
- }
|
|
|
- };
|
|
|
- LinkedMap.prototype.forEachReverse = function (callbackfn, thisArg) {
|
|
|
- var current = this._tail;
|
|
|
- while (current) {
|
|
|
- if (thisArg) {
|
|
|
- callbackfn.bind(thisArg)(current.value, current.key, this);
|
|
|
- }
|
|
|
- else {
|
|
|
- callbackfn(current.value, current.key, this);
|
|
|
- }
|
|
|
- current = current.previous;
|
|
|
- }
|
|
|
- };
|
|
|
- LinkedMap.prototype.values = function () {
|
|
|
- var result = [];
|
|
|
- var current = this._head;
|
|
|
- while (current) {
|
|
|
- result.push(current.value);
|
|
|
- current = current.next;
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- LinkedMap.prototype.keys = function () {
|
|
|
- var result = [];
|
|
|
- var current = this._head;
|
|
|
- while (current) {
|
|
|
- result.push(current.key);
|
|
|
- current = current.next;
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- /* VS Code / Monaco editor runs on es5 which has no Symbol.iterator
|
|
|
- public keys(): IterableIterator<K> {
|
|
|
- let current = this._head;
|
|
|
- let iterator: IterableIterator<K> = {
|
|
|
- [Symbol.iterator]() {
|
|
|
- return iterator;
|
|
|
- },
|
|
|
- next():IteratorResult<K> {
|
|
|
- if (current) {
|
|
|
- let result = { value: current.key, done: false };
|
|
|
- current = current.next;
|
|
|
- return result;
|
|
|
- } else {
|
|
|
- return { value: undefined, done: true };
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- return iterator;
|
|
|
- }
|
|
|
-
|
|
|
- public values(): IterableIterator<V> {
|
|
|
- let current = this._head;
|
|
|
- let iterator: IterableIterator<V> = {
|
|
|
- [Symbol.iterator]() {
|
|
|
- return iterator;
|
|
|
- },
|
|
|
- next():IteratorResult<V> {
|
|
|
- if (current) {
|
|
|
- let result = { value: current.value, done: false };
|
|
|
- current = current.next;
|
|
|
- return result;
|
|
|
- } else {
|
|
|
- return { value: undefined, done: true };
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- return iterator;
|
|
|
- }
|
|
|
- */
|
|
|
- LinkedMap.prototype.addItemFirst = function (item) {
|
|
|
- // First time Insert
|
|
|
- if (!this._head && !this._tail) {
|
|
|
- this._tail = item;
|
|
|
- }
|
|
|
- else if (!this._head) {
|
|
|
- throw new Error('Invalid list');
|
|
|
- }
|
|
|
- else {
|
|
|
- item.next = this._head;
|
|
|
- this._head.previous = item;
|
|
|
- }
|
|
|
- this._head = item;
|
|
|
- };
|
|
|
- LinkedMap.prototype.addItemLast = function (item) {
|
|
|
- // First time Insert
|
|
|
- if (!this._head && !this._tail) {
|
|
|
- this._head = item;
|
|
|
- }
|
|
|
- else if (!this._tail) {
|
|
|
- throw new Error('Invalid list');
|
|
|
- }
|
|
|
- else {
|
|
|
- item.previous = this._tail;
|
|
|
- this._tail.next = item;
|
|
|
- }
|
|
|
- this._tail = item;
|
|
|
- };
|
|
|
- LinkedMap.prototype.removeItem = function (item) {
|
|
|
- if (item === this._head && item === this._tail) {
|
|
|
- this._head = undefined;
|
|
|
- this._tail = undefined;
|
|
|
- }
|
|
|
- else if (item === this._head) {
|
|
|
- this._head = item.next;
|
|
|
- }
|
|
|
- else if (item === this._tail) {
|
|
|
- this._tail = item.previous;
|
|
|
- }
|
|
|
- else {
|
|
|
- var next = item.next;
|
|
|
- var previous = item.previous;
|
|
|
- if (!next || !previous) {
|
|
|
- throw new Error('Invalid list');
|
|
|
- }
|
|
|
- next.previous = previous;
|
|
|
- previous.next = next;
|
|
|
- }
|
|
|
- };
|
|
|
- LinkedMap.prototype.touch = function (item, touch) {
|
|
|
- if (!this._head || !this._tail) {
|
|
|
- throw new Error('Invalid list');
|
|
|
- }
|
|
|
- if ((touch !== Touch.First && touch !== Touch.Last)) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (touch === Touch.First) {
|
|
|
- if (item === this._head) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var next = item.next;
|
|
|
- var previous = item.previous;
|
|
|
- // Unlink the item
|
|
|
- if (item === this._tail) {
|
|
|
- // previous must be defined since item was not head but is tail
|
|
|
- // So there are more than on item in the map
|
|
|
- previous.next = undefined;
|
|
|
- this._tail = previous;
|
|
|
- }
|
|
|
- else {
|
|
|
- // Both next and previous are not undefined since item was neither head nor tail.
|
|
|
- next.previous = previous;
|
|
|
- previous.next = next;
|
|
|
- }
|
|
|
- // Insert the node at head
|
|
|
- item.previous = undefined;
|
|
|
- item.next = this._head;
|
|
|
- this._head.previous = item;
|
|
|
- this._head = item;
|
|
|
- }
|
|
|
- else if (touch === Touch.Last) {
|
|
|
- if (item === this._tail) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var next = item.next;
|
|
|
- var previous = item.previous;
|
|
|
- // Unlink the item.
|
|
|
- if (item === this._head) {
|
|
|
- // next must be defined since item was not tail but is head
|
|
|
- // So there are more than on item in the map
|
|
|
- next.previous = undefined;
|
|
|
- this._head = next;
|
|
|
- }
|
|
|
- else {
|
|
|
- // Both next and previous are not undefined since item was neither head nor tail.
|
|
|
- next.previous = previous;
|
|
|
- previous.next = next;
|
|
|
- }
|
|
|
- item.next = undefined;
|
|
|
- item.previous = this._tail;
|
|
|
- this._tail.next = item;
|
|
|
- this._tail = item;
|
|
|
- }
|
|
|
- };
|
|
|
- return LinkedMap;
|
|
|
- }());
|
|
|
- exports.LinkedMap = LinkedMap;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[20/*vs/base/common/strings*/], __M([1/*require*/,0/*exports*/,17/*vs/base/common/map*/]), function (require, exports, map_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * The empty string.
|
|
|
- */
|
|
|
- exports.empty = '';
|
|
|
- function isFalsyOrWhitespace(str) {
|
|
|
- if (!str || typeof str !== 'string') {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return str.trim().length === 0;
|
|
|
- }
|
|
|
- exports.isFalsyOrWhitespace = isFalsyOrWhitespace;
|
|
|
- /**
|
|
|
- * @returns the provided number with the given number of preceding zeros.
|
|
|
- */
|
|
|
- function pad(n, l, char) {
|
|
|
- if (char === void 0) { char = '0'; }
|
|
|
- var str = '' + n;
|
|
|
- var r = [str];
|
|
|
- for (var i = str.length; i < l; i++) {
|
|
|
- r.push(char);
|
|
|
- }
|
|
|
- return r.reverse().join('');
|
|
|
- }
|
|
|
- exports.pad = pad;
|
|
|
- var _formatRegexp = /{(\d+)}/g;
|
|
|
- /**
|
|
|
- * Helper to produce a string with a variable number of arguments. Insert variable segments
|
|
|
- * into the string using the {n} notation where N is the index of the argument following the string.
|
|
|
- * @param value string to which formatting is applied
|
|
|
- * @param args replacements for {n}-entries
|
|
|
- */
|
|
|
- function format(value) {
|
|
|
- var args = [];
|
|
|
- for (var _i = 1; _i < arguments.length; _i++) {
|
|
|
- args[_i - 1] = arguments[_i];
|
|
|
- }
|
|
|
- if (args.length === 0) {
|
|
|
- return value;
|
|
|
- }
|
|
|
- return value.replace(_formatRegexp, function (match, group) {
|
|
|
- var idx = parseInt(group, 10);
|
|
|
- return isNaN(idx) || idx < 0 || idx >= args.length ?
|
|
|
- match :
|
|
|
- args[idx];
|
|
|
- });
|
|
|
- }
|
|
|
- exports.format = format;
|
|
|
- /**
|
|
|
- * Converts HTML characters inside the string to use entities instead. Makes the string safe from
|
|
|
- * being used e.g. in HTMLElement.innerHTML.
|
|
|
- */
|
|
|
- function escape(html) {
|
|
|
- return html.replace(/[<|>|&]/g, function (match) {
|
|
|
- switch (match) {
|
|
|
- case '<': return '<';
|
|
|
- case '>': return '>';
|
|
|
- case '&': return '&';
|
|
|
- default: return match;
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- exports.escape = escape;
|
|
|
- /**
|
|
|
- * Escapes regular expression characters in a given string
|
|
|
- */
|
|
|
- function escapeRegExpCharacters(value) {
|
|
|
- return value.replace(/[\-\\\{\}\*\+\?\|\^\$\.\[\]\(\)\#]/g, '\\$&');
|
|
|
- }
|
|
|
- exports.escapeRegExpCharacters = escapeRegExpCharacters;
|
|
|
- /**
|
|
|
- * Removes all occurrences of needle from the beginning and end of haystack.
|
|
|
- * @param haystack string to trim
|
|
|
- * @param needle the thing to trim (default is a blank)
|
|
|
- */
|
|
|
- function trim(haystack, needle) {
|
|
|
- if (needle === void 0) { needle = ' '; }
|
|
|
- var trimmed = ltrim(haystack, needle);
|
|
|
- return rtrim(trimmed, needle);
|
|
|
- }
|
|
|
- exports.trim = trim;
|
|
|
- /**
|
|
|
- * Removes all occurrences of needle from the beginning of haystack.
|
|
|
- * @param haystack string to trim
|
|
|
- * @param needle the thing to trim
|
|
|
- */
|
|
|
- function ltrim(haystack, needle) {
|
|
|
- if (!haystack || !needle) {
|
|
|
- return haystack;
|
|
|
- }
|
|
|
- var needleLen = needle.length;
|
|
|
- if (needleLen === 0 || haystack.length === 0) {
|
|
|
- return haystack;
|
|
|
- }
|
|
|
- var offset = 0, idx = -1;
|
|
|
- while ((idx = haystack.indexOf(needle, offset)) === offset) {
|
|
|
- offset = offset + needleLen;
|
|
|
- }
|
|
|
- return haystack.substring(offset);
|
|
|
- }
|
|
|
- exports.ltrim = ltrim;
|
|
|
- /**
|
|
|
- * Removes all occurrences of needle from the end of haystack.
|
|
|
- * @param haystack string to trim
|
|
|
- * @param needle the thing to trim
|
|
|
- */
|
|
|
- function rtrim(haystack, needle) {
|
|
|
- if (!haystack || !needle) {
|
|
|
- return haystack;
|
|
|
- }
|
|
|
- var needleLen = needle.length, haystackLen = haystack.length;
|
|
|
- if (needleLen === 0 || haystackLen === 0) {
|
|
|
- return haystack;
|
|
|
- }
|
|
|
- var offset = haystackLen, idx = -1;
|
|
|
- while (true) {
|
|
|
- idx = haystack.lastIndexOf(needle, offset - 1);
|
|
|
- if (idx === -1 || idx + needleLen !== offset) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if (idx === 0) {
|
|
|
- return '';
|
|
|
- }
|
|
|
- offset = idx;
|
|
|
- }
|
|
|
- return haystack.substring(0, offset);
|
|
|
- }
|
|
|
- exports.rtrim = rtrim;
|
|
|
- function convertSimple2RegExpPattern(pattern) {
|
|
|
- return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
|
|
|
- }
|
|
|
- exports.convertSimple2RegExpPattern = convertSimple2RegExpPattern;
|
|
|
- function stripWildcards(pattern) {
|
|
|
- return pattern.replace(/\*/g, '');
|
|
|
- }
|
|
|
- exports.stripWildcards = stripWildcards;
|
|
|
- /**
|
|
|
- * Determines if haystack starts with needle.
|
|
|
- */
|
|
|
- function startsWith(haystack, needle) {
|
|
|
- if (haystack.length < needle.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var i = 0; i < needle.length; i++) {
|
|
|
- if (haystack[i] !== needle[i]) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- exports.startsWith = startsWith;
|
|
|
- /**
|
|
|
- * Determines if haystack ends with needle.
|
|
|
- */
|
|
|
- function endsWith(haystack, needle) {
|
|
|
- var diff = haystack.length - needle.length;
|
|
|
- if (diff > 0) {
|
|
|
- return haystack.indexOf(needle, diff) === diff;
|
|
|
- }
|
|
|
- else if (diff === 0) {
|
|
|
- return haystack === needle;
|
|
|
- }
|
|
|
- else {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- exports.endsWith = endsWith;
|
|
|
- function indexOfIgnoreCase(haystack, needle, position) {
|
|
|
- if (position === void 0) { position = 0; }
|
|
|
- var index = haystack.indexOf(needle, position);
|
|
|
- if (index < 0) {
|
|
|
- if (position > 0) {
|
|
|
- haystack = haystack.substr(position);
|
|
|
- }
|
|
|
- needle = escapeRegExpCharacters(needle);
|
|
|
- index = haystack.search(new RegExp(needle, 'i'));
|
|
|
- }
|
|
|
- return index;
|
|
|
- }
|
|
|
- exports.indexOfIgnoreCase = indexOfIgnoreCase;
|
|
|
- function createRegExp(searchString, isRegex, options) {
|
|
|
- if (options === void 0) { options = {}; }
|
|
|
- if (!searchString) {
|
|
|
- throw new Error('Cannot create regex from empty string');
|
|
|
- }
|
|
|
- if (!isRegex) {
|
|
|
- searchString = escapeRegExpCharacters(searchString);
|
|
|
- }
|
|
|
- if (options.wholeWord) {
|
|
|
- if (!/\B/.test(searchString.charAt(0))) {
|
|
|
- searchString = '\\b' + searchString;
|
|
|
- }
|
|
|
- if (!/\B/.test(searchString.charAt(searchString.length - 1))) {
|
|
|
- searchString = searchString + '\\b';
|
|
|
- }
|
|
|
- }
|
|
|
- var modifiers = '';
|
|
|
- if (options.global) {
|
|
|
- modifiers += 'g';
|
|
|
- }
|
|
|
- if (!options.matchCase) {
|
|
|
- modifiers += 'i';
|
|
|
- }
|
|
|
- if (options.multiline) {
|
|
|
- modifiers += 'm';
|
|
|
- }
|
|
|
- return new RegExp(searchString, modifiers);
|
|
|
- }
|
|
|
- exports.createRegExp = createRegExp;
|
|
|
- function regExpLeadsToEndlessLoop(regexp) {
|
|
|
- // Exit early if it's one of these special cases which are meant to match
|
|
|
- // against an empty string
|
|
|
- if (regexp.source === '^' || regexp.source === '^$' || regexp.source === '$') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- // We check against an empty string. If the regular expression doesn't advance
|
|
|
- // (e.g. ends in an endless loop) it will match an empty string.
|
|
|
- var match = regexp.exec('');
|
|
|
- return (match && regexp.lastIndex === 0);
|
|
|
- }
|
|
|
- exports.regExpLeadsToEndlessLoop = regExpLeadsToEndlessLoop;
|
|
|
- /**
|
|
|
- * The normalize() method returns the Unicode Normalization Form of a given string. The form will be
|
|
|
- * the Normalization Form Canonical Composition.
|
|
|
- *
|
|
|
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize}
|
|
|
- */
|
|
|
- exports.canNormalize = typeof (''.normalize) === 'function';
|
|
|
- var nonAsciiCharactersPattern = /[^\u0000-\u0080]/;
|
|
|
- var normalizedCache = new map_1.BoundedMap(10000); // bounded to 10000 elements
|
|
|
- function normalizeNFC(str) {
|
|
|
- if (!exports.canNormalize || !str) {
|
|
|
- return str;
|
|
|
- }
|
|
|
- var cached = normalizedCache.get(str);
|
|
|
- if (cached) {
|
|
|
- return cached;
|
|
|
- }
|
|
|
- var res;
|
|
|
- if (nonAsciiCharactersPattern.test(str)) {
|
|
|
- res = str.normalize('NFC');
|
|
|
- }
|
|
|
- else {
|
|
|
- res = str;
|
|
|
- }
|
|
|
- // Use the cache for fast lookup
|
|
|
- normalizedCache.set(str, res);
|
|
|
- return res;
|
|
|
- }
|
|
|
- exports.normalizeNFC = normalizeNFC;
|
|
|
- /**
|
|
|
- * Returns first index of the string that is not whitespace.
|
|
|
- * If string is empty or contains only whitespaces, returns -1
|
|
|
- */
|
|
|
- function firstNonWhitespaceIndex(str) {
|
|
|
- for (var i = 0, len = str.length; i < len; i++) {
|
|
|
- var chCode = str.charCodeAt(i);
|
|
|
- if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- exports.firstNonWhitespaceIndex = firstNonWhitespaceIndex;
|
|
|
- /**
|
|
|
- * Returns the leading whitespace of the string.
|
|
|
- * If the string contains only whitespaces, returns entire string
|
|
|
- */
|
|
|
- function getLeadingWhitespace(str, start, end) {
|
|
|
- if (start === void 0) { start = 0; }
|
|
|
- if (end === void 0) { end = str.length; }
|
|
|
- for (var i = start; i < end; i++) {
|
|
|
- var chCode = str.charCodeAt(i);
|
|
|
- if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
|
|
|
- return str.substring(start, i);
|
|
|
- }
|
|
|
- }
|
|
|
- return str.substring(start, end);
|
|
|
- }
|
|
|
- exports.getLeadingWhitespace = getLeadingWhitespace;
|
|
|
- /**
|
|
|
- * Returns last index of the string that is not whitespace.
|
|
|
- * If string is empty or contains only whitespaces, returns -1
|
|
|
- */
|
|
|
- function lastNonWhitespaceIndex(str, startIndex) {
|
|
|
- if (startIndex === void 0) { startIndex = str.length - 1; }
|
|
|
- for (var i = startIndex; i >= 0; i--) {
|
|
|
- var chCode = str.charCodeAt(i);
|
|
|
- if (chCode !== 32 /* Space */ && chCode !== 9 /* Tab */) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return -1;
|
|
|
- }
|
|
|
- exports.lastNonWhitespaceIndex = lastNonWhitespaceIndex;
|
|
|
- function compare(a, b) {
|
|
|
- if (a < b) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- else if (a > b) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- exports.compare = compare;
|
|
|
- function compareIgnoreCase(a, b) {
|
|
|
- var len = Math.min(a.length, b.length);
|
|
|
- for (var i = 0; i < len; i++) {
|
|
|
- var codeA = a.charCodeAt(i);
|
|
|
- var codeB = b.charCodeAt(i);
|
|
|
- if (codeA === codeB) {
|
|
|
- // equal
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (isUpperAsciiLetter(codeA)) {
|
|
|
- codeA += 32;
|
|
|
- }
|
|
|
- if (isUpperAsciiLetter(codeB)) {
|
|
|
- codeB += 32;
|
|
|
- }
|
|
|
- var diff = codeA - codeB;
|
|
|
- if (diff === 0) {
|
|
|
- // equal -> ignoreCase
|
|
|
- continue;
|
|
|
- }
|
|
|
- else if (isLowerAsciiLetter(codeA) && isLowerAsciiLetter(codeB)) {
|
|
|
- //
|
|
|
- return diff;
|
|
|
- }
|
|
|
- else {
|
|
|
- return compare(a.toLowerCase(), b.toLowerCase());
|
|
|
- }
|
|
|
- }
|
|
|
- if (a.length < b.length) {
|
|
|
- return -1;
|
|
|
- }
|
|
|
- else if (a.length > b.length) {
|
|
|
- return 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- exports.compareIgnoreCase = compareIgnoreCase;
|
|
|
- function isLowerAsciiLetter(code) {
|
|
|
- return code >= 97 /* a */ && code <= 122 /* z */;
|
|
|
- }
|
|
|
- function isUpperAsciiLetter(code) {
|
|
|
- return code >= 65 /* A */ && code <= 90 /* Z */;
|
|
|
- }
|
|
|
- function isAsciiLetter(code) {
|
|
|
- return isLowerAsciiLetter(code) || isUpperAsciiLetter(code);
|
|
|
- }
|
|
|
- function equalsIgnoreCase(a, b) {
|
|
|
- var len1 = a ? a.length : 0;
|
|
|
- var len2 = b ? b.length : 0;
|
|
|
- if (len1 !== len2) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return doEqualsIgnoreCase(a, b);
|
|
|
- }
|
|
|
- exports.equalsIgnoreCase = equalsIgnoreCase;
|
|
|
- function doEqualsIgnoreCase(a, b, stopAt) {
|
|
|
- if (stopAt === void 0) { stopAt = a.length; }
|
|
|
- if (typeof a !== 'string' || typeof b !== 'string') {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var i = 0; i < stopAt; i++) {
|
|
|
- var codeA = a.charCodeAt(i);
|
|
|
- var codeB = b.charCodeAt(i);
|
|
|
- if (codeA === codeB) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- // a-z A-Z
|
|
|
- if (isAsciiLetter(codeA) && isAsciiLetter(codeB)) {
|
|
|
- var diff = Math.abs(codeA - codeB);
|
|
|
- if (diff !== 0 && diff !== 32) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- if (String.fromCharCode(codeA).toLowerCase() !== String.fromCharCode(codeB).toLowerCase()) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- function beginsWithIgnoreCase(str, candidate) {
|
|
|
- var candidateLength = candidate.length;
|
|
|
- if (candidate.length > str.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return doEqualsIgnoreCase(str, candidate, candidateLength);
|
|
|
- }
|
|
|
- exports.beginsWithIgnoreCase = beginsWithIgnoreCase;
|
|
|
- /**
|
|
|
- * @returns the length of the common prefix of the two strings.
|
|
|
- */
|
|
|
- function commonPrefixLength(a, b) {
|
|
|
- var i, len = Math.min(a.length, b.length);
|
|
|
- for (i = 0; i < len; i++) {
|
|
|
- if (a.charCodeAt(i) !== b.charCodeAt(i)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return len;
|
|
|
- }
|
|
|
- exports.commonPrefixLength = commonPrefixLength;
|
|
|
- /**
|
|
|
- * @returns the length of the common suffix of the two strings.
|
|
|
- */
|
|
|
- function commonSuffixLength(a, b) {
|
|
|
- var i, len = Math.min(a.length, b.length);
|
|
|
- var aLastIndex = a.length - 1;
|
|
|
- var bLastIndex = b.length - 1;
|
|
|
- for (i = 0; i < len; i++) {
|
|
|
- if (a.charCodeAt(aLastIndex - i) !== b.charCodeAt(bLastIndex - i)) {
|
|
|
- return i;
|
|
|
- }
|
|
|
- }
|
|
|
- return len;
|
|
|
- }
|
|
|
- exports.commonSuffixLength = commonSuffixLength;
|
|
|
- function substrEquals(a, aStart, aEnd, b, bStart, bEnd) {
|
|
|
- while (aStart < aEnd && bStart < bEnd) {
|
|
|
- if (a[aStart] !== b[bStart]) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- aStart += 1;
|
|
|
- bStart += 1;
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Return the overlap between the suffix of `a` and the prefix of `b`.
|
|
|
- * For instance `overlap("foobar", "arr, I'm a pirate") === 2`.
|
|
|
- */
|
|
|
- function overlap(a, b) {
|
|
|
- var aEnd = a.length;
|
|
|
- var bEnd = b.length;
|
|
|
- var aStart = aEnd - bEnd;
|
|
|
- if (aStart === 0) {
|
|
|
- return a === b ? aEnd : 0;
|
|
|
- }
|
|
|
- else if (aStart < 0) {
|
|
|
- bEnd += aStart;
|
|
|
- aStart = 0;
|
|
|
- }
|
|
|
- while (aStart < aEnd && bEnd > 0) {
|
|
|
- if (substrEquals(a, aStart, aEnd, b, 0, bEnd)) {
|
|
|
- return bEnd;
|
|
|
- }
|
|
|
- bEnd -= 1;
|
|
|
- aStart += 1;
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- exports.overlap = overlap;
|
|
|
- // --- unicode
|
|
|
- // http://en.wikipedia.org/wiki/Surrogate_pair
|
|
|
- // Returns the code point starting at a specified index in a string
|
|
|
- // Code points U+0000 to U+D7FF and U+E000 to U+FFFF are represented on a single character
|
|
|
- // Code points U+10000 to U+10FFFF are represented on two consecutive characters
|
|
|
- //export function getUnicodePoint(str:string, index:number, len:number):number {
|
|
|
- // let chrCode = str.charCodeAt(index);
|
|
|
- // if (0xD800 <= chrCode && chrCode <= 0xDBFF && index + 1 < len) {
|
|
|
- // let nextChrCode = str.charCodeAt(index + 1);
|
|
|
- // if (0xDC00 <= nextChrCode && nextChrCode <= 0xDFFF) {
|
|
|
- // return (chrCode - 0xD800) << 10 + (nextChrCode - 0xDC00) + 0x10000;
|
|
|
- // }
|
|
|
- // }
|
|
|
- // return chrCode;
|
|
|
- //}
|
|
|
- function isHighSurrogate(charCode) {
|
|
|
- return (0xD800 <= charCode && charCode <= 0xDBFF);
|
|
|
- }
|
|
|
- exports.isHighSurrogate = isHighSurrogate;
|
|
|
- function isLowSurrogate(charCode) {
|
|
|
- return (0xDC00 <= charCode && charCode <= 0xDFFF);
|
|
|
- }
|
|
|
- exports.isLowSurrogate = isLowSurrogate;
|
|
|
- /**
|
|
|
- * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-rtl-test.js
|
|
|
- */
|
|
|
- var 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-\u0815\u081A\u0824\u0828\u0830-\u0858\u085E-\u08BD\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFD3D\uFD50-\uFDFC\uFE70-\uFEFC]|\uD802[\uDC00-\uDD1B\uDD20-\uDE00\uDE10-\uDE33\uDE40-\uDEE4\uDEEB-\uDF35\uDF40-\uDFFF]|\uD803[\uDC00-\uDCFF]|\uD83A[\uDC00-\uDCCF\uDD00-\uDD43\uDD50-\uDFFF]|\uD83B[\uDC00-\uDEBB])/;
|
|
|
- /**
|
|
|
- * Returns true if `str` contains any Unicode character that is classified as "R" or "AL".
|
|
|
- */
|
|
|
- function containsRTL(str) {
|
|
|
- return CONTAINS_RTL.test(str);
|
|
|
- }
|
|
|
- exports.containsRTL = containsRTL;
|
|
|
- /**
|
|
|
- * Generated using https://github.com/alexandrudima/unicode-utils/blob/master/generate-emoji-test.js
|
|
|
- */
|
|
|
- var CONTAINS_EMOJI = /(?:[\u231A\u231B\u23F0\u23F3\u2600-\u27BF\u2B50\u2B55]|\uD83C[\uDDE6-\uDDFF\uDF00-\uDFFF]|\uD83D[\uDC00-\uDE4F\uDE80-\uDEF8]|\uD83E[\uDD00-\uDDE6])/;
|
|
|
- function containsEmoji(str) {
|
|
|
- return CONTAINS_EMOJI.test(str);
|
|
|
- }
|
|
|
- exports.containsEmoji = containsEmoji;
|
|
|
- var IS_BASIC_ASCII = /^[\t\n\r\x20-\x7E]*$/;
|
|
|
- /**
|
|
|
- * Returns true if `str` contains only basic ASCII characters in the range 32 - 126 (including 32 and 126) or \n, \r, \t
|
|
|
- */
|
|
|
- function isBasicASCII(str) {
|
|
|
- return IS_BASIC_ASCII.test(str);
|
|
|
- }
|
|
|
- exports.isBasicASCII = isBasicASCII;
|
|
|
- function containsFullWidthCharacter(str) {
|
|
|
- for (var i = 0, len = str.length; i < len; i++) {
|
|
|
- if (isFullWidthCharacter(str.charCodeAt(i))) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
- }
|
|
|
- exports.containsFullWidthCharacter = containsFullWidthCharacter;
|
|
|
- function isFullWidthCharacter(charCode) {
|
|
|
- // Do a cheap trick to better support wrapping of wide characters, treat them as 2 columns
|
|
|
- // http://jrgraphix.net/research/unicode_blocks.php
|
|
|
- // 2E80 — 2EFF CJK Radicals Supplement
|
|
|
- // 2F00 — 2FDF Kangxi Radicals
|
|
|
- // 2FF0 — 2FFF Ideographic Description Characters
|
|
|
- // 3000 — 303F CJK Symbols and Punctuation
|
|
|
- // 3040 — 309F Hiragana
|
|
|
- // 30A0 — 30FF Katakana
|
|
|
- // 3100 — 312F Bopomofo
|
|
|
- // 3130 — 318F Hangul Compatibility Jamo
|
|
|
- // 3190 — 319F Kanbun
|
|
|
- // 31A0 — 31BF Bopomofo Extended
|
|
|
- // 31F0 — 31FF Katakana Phonetic Extensions
|
|
|
- // 3200 — 32FF Enclosed CJK Letters and Months
|
|
|
- // 3300 — 33FF CJK Compatibility
|
|
|
- // 3400 — 4DBF CJK Unified Ideographs Extension A
|
|
|
- // 4DC0 — 4DFF Yijing Hexagram Symbols
|
|
|
- // 4E00 — 9FFF CJK Unified Ideographs
|
|
|
- // A000 — A48F Yi Syllables
|
|
|
- // A490 — A4CF Yi Radicals
|
|
|
- // AC00 — D7AF Hangul Syllables
|
|
|
- // [IGNORE] D800 — DB7F High Surrogates
|
|
|
- // [IGNORE] DB80 — DBFF High Private Use Surrogates
|
|
|
- // [IGNORE] DC00 — DFFF Low Surrogates
|
|
|
- // [IGNORE] E000 — F8FF Private Use Area
|
|
|
- // F900 — FAFF CJK Compatibility Ideographs
|
|
|
- // [IGNORE] FB00 — FB4F Alphabetic Presentation Forms
|
|
|
- // [IGNORE] FB50 — FDFF Arabic Presentation Forms-A
|
|
|
- // [IGNORE] FE00 — FE0F Variation Selectors
|
|
|
- // [IGNORE] FE20 — FE2F Combining Half Marks
|
|
|
- // [IGNORE] FE30 — FE4F CJK Compatibility Forms
|
|
|
- // [IGNORE] FE50 — FE6F Small Form Variants
|
|
|
- // [IGNORE] FE70 — FEFF Arabic Presentation Forms-B
|
|
|
- // FF00 — FFEF Halfwidth and Fullwidth Forms
|
|
|
- // [https://en.wikipedia.org/wiki/Halfwidth_and_fullwidth_forms]
|
|
|
- // of which FF01 - FF5E fullwidth ASCII of 21 to 7E
|
|
|
- // [IGNORE] and FF65 - FFDC halfwidth of Katakana and Hangul
|
|
|
- // [IGNORE] FFF0 — FFFF Specials
|
|
|
- charCode = +charCode; // @perf
|
|
|
- return ((charCode >= 0x2E80 && charCode <= 0xD7AF)
|
|
|
- || (charCode >= 0xF900 && charCode <= 0xFAFF)
|
|
|
- || (charCode >= 0xFF01 && charCode <= 0xFF5E));
|
|
|
- }
|
|
|
- exports.isFullWidthCharacter = isFullWidthCharacter;
|
|
|
- /**
|
|
|
- * Computes the difference score for two strings. More similar strings have a higher score.
|
|
|
- * We use largest common subsequence dynamic programming approach but penalize in the end for length differences.
|
|
|
- * Strings that have a large length difference will get a bad default score 0.
|
|
|
- * Complexity - both time and space O(first.length * second.length)
|
|
|
- * Dynamic programming LCS computation http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
|
|
|
- *
|
|
|
- * @param first a string
|
|
|
- * @param second a string
|
|
|
- */
|
|
|
- function difference(first, second, maxLenDelta) {
|
|
|
- if (maxLenDelta === void 0) { maxLenDelta = 4; }
|
|
|
- var lengthDifference = Math.abs(first.length - second.length);
|
|
|
- // We only compute score if length of the currentWord and length of entry.name are similar.
|
|
|
- if (lengthDifference > maxLenDelta) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- // Initialize LCS (largest common subsequence) matrix.
|
|
|
- var LCS = [];
|
|
|
- var zeroArray = [];
|
|
|
- var i, j;
|
|
|
- for (i = 0; i < second.length + 1; ++i) {
|
|
|
- zeroArray.push(0);
|
|
|
- }
|
|
|
- for (i = 0; i < first.length + 1; ++i) {
|
|
|
- LCS.push(zeroArray);
|
|
|
- }
|
|
|
- for (i = 1; i < first.length + 1; ++i) {
|
|
|
- for (j = 1; j < second.length + 1; ++j) {
|
|
|
- if (first[i - 1] === second[j - 1]) {
|
|
|
- LCS[i][j] = LCS[i - 1][j - 1] + 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- LCS[i][j] = Math.max(LCS[i - 1][j], LCS[i][j - 1]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return LCS[first.length][second.length] - Math.sqrt(lengthDifference);
|
|
|
- }
|
|
|
- exports.difference = difference;
|
|
|
- /**
|
|
|
- * Returns an array in which every entry is the offset of a
|
|
|
- * line. There is always one entry which is zero.
|
|
|
- */
|
|
|
- function computeLineStarts(text) {
|
|
|
- var regexp = /\r\n|\r|\n/g, ret = [0], match;
|
|
|
- while ((match = regexp.exec(text))) {
|
|
|
- ret.push(regexp.lastIndex);
|
|
|
- }
|
|
|
- return ret;
|
|
|
- }
|
|
|
- exports.computeLineStarts = computeLineStarts;
|
|
|
- /**
|
|
|
- * Given a string and a max length returns a shorted version. Shorting
|
|
|
- * happens at favorable positions - such as whitespace or punctuation characters.
|
|
|
- */
|
|
|
- function lcut(text, n) {
|
|
|
- if (text.length < n) {
|
|
|
- return text;
|
|
|
- }
|
|
|
- var segments = text.split(/\b/), count = 0;
|
|
|
- for (var i = segments.length - 1; i >= 0; i--) {
|
|
|
- count += segments[i].length;
|
|
|
- if (count > n) {
|
|
|
- segments.splice(0, i);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return segments.join(exports.empty).replace(/^\s/, exports.empty);
|
|
|
- }
|
|
|
- exports.lcut = lcut;
|
|
|
- // Escape codes
|
|
|
- // http://en.wikipedia.org/wiki/ANSI_escape_code
|
|
|
- var EL = /\x1B\x5B[12]?K/g; // Erase in line
|
|
|
- var COLOR_START = /\x1b\[\d+m/g; // Color
|
|
|
- var COLOR_END = /\x1b\[0?m/g; // Color
|
|
|
- function removeAnsiEscapeCodes(str) {
|
|
|
- if (str) {
|
|
|
- str = str.replace(EL, '');
|
|
|
- str = str.replace(COLOR_START, '');
|
|
|
- str = str.replace(COLOR_END, '');
|
|
|
- }
|
|
|
- return str;
|
|
|
- }
|
|
|
- exports.removeAnsiEscapeCodes = removeAnsiEscapeCodes;
|
|
|
- // -- UTF-8 BOM
|
|
|
- exports.UTF8_BOM_CHARACTER = String.fromCharCode(65279 /* UTF8_BOM */);
|
|
|
- function startsWithUTF8BOM(str) {
|
|
|
- return (str && str.length > 0 && str.charCodeAt(0) === 65279 /* UTF8_BOM */);
|
|
|
- }
|
|
|
- exports.startsWithUTF8BOM = startsWithUTF8BOM;
|
|
|
- /**
|
|
|
- * Appends two strings. If the appended result is longer than maxLength,
|
|
|
- * trims the start of the result and replaces it with '...'.
|
|
|
- */
|
|
|
- function appendWithLimit(first, second, maxLength) {
|
|
|
- var newLength = first.length + second.length;
|
|
|
- if (newLength > maxLength) {
|
|
|
- first = '...' + first.substr(newLength - maxLength);
|
|
|
- }
|
|
|
- if (second.length > maxLength) {
|
|
|
- first += second.substr(second.length - maxLength);
|
|
|
- }
|
|
|
- else {
|
|
|
- first += second;
|
|
|
- }
|
|
|
- return first;
|
|
|
- }
|
|
|
- exports.appendWithLimit = appendWithLimit;
|
|
|
- function safeBtoa(str) {
|
|
|
- return btoa(encodeURIComponent(str)); // we use encodeURIComponent because btoa fails for non Latin 1 values
|
|
|
- }
|
|
|
- exports.safeBtoa = safeBtoa;
|
|
|
- function repeat(s, count) {
|
|
|
- var result = '';
|
|
|
- for (var i = 0; i < count; i++) {
|
|
|
- result += s;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.repeat = repeat;
|
|
|
-});
|
|
|
-
|
|
|
-/**
|
|
|
- * Extracted from https://github.com/winjs/winjs
|
|
|
- * Version: 4.4.0(ec3258a9f3a36805a187848984e3bb938044178d)
|
|
|
- * Copyright (c) Microsoft Corporation.
|
|
|
- * All Rights Reserved.
|
|
|
- * Licensed under the MIT License.
|
|
|
- */
|
|
|
-(function() {
|
|
|
-
|
|
|
-var _modules = {};
|
|
|
-_modules["WinJS/Core/_WinJS"] = {};
|
|
|
-
|
|
|
-var _winjs = function(moduleId, deps, factory) {
|
|
|
- var exports = {};
|
|
|
- var exportsPassedIn = false;
|
|
|
-
|
|
|
- var depsValues = deps.map(function(dep) {
|
|
|
- if (dep === 'exports') {
|
|
|
- exportsPassedIn = true;
|
|
|
- return exports;
|
|
|
- }
|
|
|
- return _modules[dep];
|
|
|
- });
|
|
|
-
|
|
|
- var result = factory.apply({}, depsValues);
|
|
|
-
|
|
|
- _modules[moduleId] = exportsPassedIn ? exports : result;
|
|
|
-};
|
|
|
-
|
|
|
-
|
|
|
-_winjs("WinJS/Core/_Global", [], function () {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- // Appease jshint
|
|
|
- /* global window, self, global */
|
|
|
-
|
|
|
- var globalObject =
|
|
|
- typeof window !== 'undefined' ? window :
|
|
|
- typeof self !== 'undefined' ? self :
|
|
|
- typeof global !== 'undefined' ? global :
|
|
|
- {};
|
|
|
- return globalObject;
|
|
|
-});
|
|
|
-
|
|
|
-_winjs("WinJS/Core/_BaseCoreUtils", ["WinJS/Core/_Global"], function baseCoreUtilsInit(_Global) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- var hasWinRT = !!_Global.Windows;
|
|
|
-
|
|
|
- function markSupportedForProcessing(func) {
|
|
|
- /// <signature helpKeyword="WinJS.Utilities.markSupportedForProcessing">
|
|
|
- /// <summary locid="WinJS.Utilities.markSupportedForProcessing">
|
|
|
- /// Marks a function as being compatible with declarative processing, such as WinJS.UI.processAll
|
|
|
- /// or WinJS.Binding.processAll.
|
|
|
- /// </summary>
|
|
|
- /// <param name="func" type="Function" locid="WinJS.Utilities.markSupportedForProcessing_p:func">
|
|
|
- /// The function to be marked as compatible with declarative processing.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Function" locid="WinJS.Utilities.markSupportedForProcessing_returnValue">
|
|
|
- /// The input function.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- func.supportedForProcessing = true;
|
|
|
- return func;
|
|
|
- }
|
|
|
-
|
|
|
- return {
|
|
|
- hasWinRT: hasWinRT,
|
|
|
- markSupportedForProcessing: markSupportedForProcessing,
|
|
|
- _setImmediate: _Global.setImmediate ? _Global.setImmediate.bind(_Global) : function (handler) {
|
|
|
- _Global.setTimeout(handler, 0);
|
|
|
- }
|
|
|
- };
|
|
|
-});
|
|
|
-_winjs("WinJS/Core/_WriteProfilerMark", ["WinJS/Core/_Global"], function profilerInit(_Global) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- return _Global.msWriteProfilerMark || function () { };
|
|
|
-});
|
|
|
-_winjs("WinJS/Core/_Base", ["WinJS/Core/_WinJS","WinJS/Core/_Global","WinJS/Core/_BaseCoreUtils","WinJS/Core/_WriteProfilerMark"], function baseInit(_WinJS, _Global, _BaseCoreUtils, _WriteProfilerMark) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- function initializeProperties(target, members, prefix) {
|
|
|
- var keys = Object.keys(members);
|
|
|
- var isArray = Array.isArray(target);
|
|
|
- var properties;
|
|
|
- var i, len;
|
|
|
- for (i = 0, len = keys.length; i < len; i++) {
|
|
|
- var key = keys[i];
|
|
|
- var enumerable = key.charCodeAt(0) !== /*_*/95;
|
|
|
- var member = members[key];
|
|
|
- if (member && typeof member === 'object') {
|
|
|
- if (member.value !== undefined || typeof member.get === 'function' || typeof member.set === 'function') {
|
|
|
- if (member.enumerable === undefined) {
|
|
|
- member.enumerable = enumerable;
|
|
|
- }
|
|
|
- if (prefix && member.setName && typeof member.setName === 'function') {
|
|
|
- member.setName(prefix + "." + key);
|
|
|
- }
|
|
|
- properties = properties || {};
|
|
|
- properties[key] = member;
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!enumerable) {
|
|
|
- properties = properties || {};
|
|
|
- properties[key] = { value: member, enumerable: enumerable, configurable: true, writable: true };
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (isArray) {
|
|
|
- target.forEach(function (target) {
|
|
|
- target[key] = member;
|
|
|
- });
|
|
|
- } else {
|
|
|
- target[key] = member;
|
|
|
- }
|
|
|
- }
|
|
|
- if (properties) {
|
|
|
- if (isArray) {
|
|
|
- target.forEach(function (target) {
|
|
|
- Object.defineProperties(target, properties);
|
|
|
- });
|
|
|
- } else {
|
|
|
- Object.defineProperties(target, properties);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- (function () {
|
|
|
-
|
|
|
- var _rootNamespace = _WinJS;
|
|
|
- if (!_rootNamespace.Namespace) {
|
|
|
- _rootNamespace.Namespace = Object.create(Object.prototype);
|
|
|
- }
|
|
|
-
|
|
|
- function createNamespace(parentNamespace, name) {
|
|
|
- var currentNamespace = parentNamespace || {};
|
|
|
- if (name) {
|
|
|
- var namespaceFragments = name.split(".");
|
|
|
- if (currentNamespace === _Global && namespaceFragments[0] === "WinJS") {
|
|
|
- currentNamespace = _WinJS;
|
|
|
- namespaceFragments.splice(0, 1);
|
|
|
- }
|
|
|
- for (var i = 0, len = namespaceFragments.length; i < len; i++) {
|
|
|
- var namespaceName = namespaceFragments[i];
|
|
|
- if (!currentNamespace[namespaceName]) {
|
|
|
- Object.defineProperty(currentNamespace, namespaceName,
|
|
|
- { value: {}, writable: false, enumerable: true, configurable: true }
|
|
|
- );
|
|
|
- }
|
|
|
- currentNamespace = currentNamespace[namespaceName];
|
|
|
- }
|
|
|
- }
|
|
|
- return currentNamespace;
|
|
|
- }
|
|
|
-
|
|
|
- function defineWithParent(parentNamespace, name, members) {
|
|
|
- /// <signature helpKeyword="WinJS.Namespace.defineWithParent">
|
|
|
- /// <summary locid="WinJS.Namespace.defineWithParent">
|
|
|
- /// Defines a new namespace with the specified name under the specified parent namespace.
|
|
|
- /// </summary>
|
|
|
- /// <param name="parentNamespace" type="Object" locid="WinJS.Namespace.defineWithParent_p:parentNamespace">
|
|
|
- /// The parent namespace.
|
|
|
- /// </param>
|
|
|
- /// <param name="name" type="String" locid="WinJS.Namespace.defineWithParent_p:name">
|
|
|
- /// The name of the new namespace.
|
|
|
- /// </param>
|
|
|
- /// <param name="members" type="Object" locid="WinJS.Namespace.defineWithParent_p:members">
|
|
|
- /// The members of the new namespace.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Object" locid="WinJS.Namespace.defineWithParent_returnValue">
|
|
|
- /// The newly-defined namespace.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- var currentNamespace = createNamespace(parentNamespace, name);
|
|
|
-
|
|
|
- if (members) {
|
|
|
- initializeProperties(currentNamespace, members, name || "<ANONYMOUS>");
|
|
|
- }
|
|
|
-
|
|
|
- return currentNamespace;
|
|
|
- }
|
|
|
-
|
|
|
- function define(name, members) {
|
|
|
- /// <signature helpKeyword="WinJS.Namespace.define">
|
|
|
- /// <summary locid="WinJS.Namespace.define">
|
|
|
- /// Defines a new namespace with the specified name.
|
|
|
- /// </summary>
|
|
|
- /// <param name="name" type="String" locid="WinJS.Namespace.define_p:name">
|
|
|
- /// The name of the namespace. This could be a dot-separated name for nested namespaces.
|
|
|
- /// </param>
|
|
|
- /// <param name="members" type="Object" locid="WinJS.Namespace.define_p:members">
|
|
|
- /// The members of the new namespace.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Object" locid="WinJS.Namespace.define_returnValue">
|
|
|
- /// The newly-defined namespace.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return defineWithParent(_Global, name, members);
|
|
|
- }
|
|
|
-
|
|
|
- var LazyStates = {
|
|
|
- uninitialized: 1,
|
|
|
- working: 2,
|
|
|
- initialized: 3,
|
|
|
- };
|
|
|
-
|
|
|
- function lazy(f) {
|
|
|
- var name;
|
|
|
- var state = LazyStates.uninitialized;
|
|
|
- var result;
|
|
|
- return {
|
|
|
- setName: function (value) {
|
|
|
- name = value;
|
|
|
- },
|
|
|
- get: function () {
|
|
|
- switch (state) {
|
|
|
- case LazyStates.initialized:
|
|
|
- return result;
|
|
|
-
|
|
|
- case LazyStates.uninitialized:
|
|
|
- state = LazyStates.working;
|
|
|
- try {
|
|
|
- _WriteProfilerMark("WinJS.Namespace._lazy:" + name + ",StartTM");
|
|
|
- result = f();
|
|
|
- } finally {
|
|
|
- _WriteProfilerMark("WinJS.Namespace._lazy:" + name + ",StopTM");
|
|
|
- state = LazyStates.uninitialized;
|
|
|
- }
|
|
|
- f = null;
|
|
|
- state = LazyStates.initialized;
|
|
|
- return result;
|
|
|
-
|
|
|
- case LazyStates.working:
|
|
|
- throw "Illegal: reentrancy on initialization";
|
|
|
-
|
|
|
- default:
|
|
|
- throw "Illegal";
|
|
|
- }
|
|
|
- },
|
|
|
- set: function (value) {
|
|
|
- switch (state) {
|
|
|
- case LazyStates.working:
|
|
|
- throw "Illegal: reentrancy on initialization";
|
|
|
-
|
|
|
- default:
|
|
|
- state = LazyStates.initialized;
|
|
|
- result = value;
|
|
|
- break;
|
|
|
- }
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true,
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- // helper for defining AMD module members
|
|
|
- function moduleDefine(exports, name, members) {
|
|
|
- var target = [exports];
|
|
|
- var publicNS = null;
|
|
|
- if (name) {
|
|
|
- publicNS = createNamespace(_Global, name);
|
|
|
- target.push(publicNS);
|
|
|
- }
|
|
|
- initializeProperties(target, members, name || "<ANONYMOUS>");
|
|
|
- return publicNS;
|
|
|
- }
|
|
|
-
|
|
|
- // Establish members of the "WinJS.Namespace" namespace
|
|
|
- Object.defineProperties(_rootNamespace.Namespace, {
|
|
|
-
|
|
|
- defineWithParent: { value: defineWithParent, writable: true, enumerable: true, configurable: true },
|
|
|
-
|
|
|
- define: { value: define, writable: true, enumerable: true, configurable: true },
|
|
|
-
|
|
|
- _lazy: { value: lazy, writable: true, enumerable: true, configurable: true },
|
|
|
-
|
|
|
- _moduleDefine: { value: moduleDefine, writable: true, enumerable: true, configurable: true }
|
|
|
-
|
|
|
- });
|
|
|
-
|
|
|
- })();
|
|
|
-
|
|
|
- (function () {
|
|
|
-
|
|
|
- function define(constructor, instanceMembers, staticMembers) {
|
|
|
- /// <signature helpKeyword="WinJS.Class.define">
|
|
|
- /// <summary locid="WinJS.Class.define">
|
|
|
- /// Defines a class using the given constructor and the specified instance members.
|
|
|
- /// </summary>
|
|
|
- /// <param name="constructor" type="Function" locid="WinJS.Class.define_p:constructor">
|
|
|
- /// A constructor function that is used to instantiate this class.
|
|
|
- /// </param>
|
|
|
- /// <param name="instanceMembers" type="Object" locid="WinJS.Class.define_p:instanceMembers">
|
|
|
- /// The set of instance fields, properties, and methods made available on the class.
|
|
|
- /// </param>
|
|
|
- /// <param name="staticMembers" type="Object" locid="WinJS.Class.define_p:staticMembers">
|
|
|
- /// The set of static fields, properties, and methods made available on the class.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Function" locid="WinJS.Class.define_returnValue">
|
|
|
- /// The newly-defined class.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- constructor = constructor || function () { };
|
|
|
- _BaseCoreUtils.markSupportedForProcessing(constructor);
|
|
|
- if (instanceMembers) {
|
|
|
- initializeProperties(constructor.prototype, instanceMembers);
|
|
|
- }
|
|
|
- if (staticMembers) {
|
|
|
- initializeProperties(constructor, staticMembers);
|
|
|
- }
|
|
|
- return constructor;
|
|
|
- }
|
|
|
-
|
|
|
- function derive(baseClass, constructor, instanceMembers, staticMembers) {
|
|
|
- /// <signature helpKeyword="WinJS.Class.derive">
|
|
|
- /// <summary locid="WinJS.Class.derive">
|
|
|
- /// Creates a sub-class based on the supplied baseClass parameter, using prototypal inheritance.
|
|
|
- /// </summary>
|
|
|
- /// <param name="baseClass" type="Function" locid="WinJS.Class.derive_p:baseClass">
|
|
|
- /// The class to inherit from.
|
|
|
- /// </param>
|
|
|
- /// <param name="constructor" type="Function" locid="WinJS.Class.derive_p:constructor">
|
|
|
- /// A constructor function that is used to instantiate this class.
|
|
|
- /// </param>
|
|
|
- /// <param name="instanceMembers" type="Object" locid="WinJS.Class.derive_p:instanceMembers">
|
|
|
- /// The set of instance fields, properties, and methods to be made available on the class.
|
|
|
- /// </param>
|
|
|
- /// <param name="staticMembers" type="Object" locid="WinJS.Class.derive_p:staticMembers">
|
|
|
- /// The set of static fields, properties, and methods to be made available on the class.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Function" locid="WinJS.Class.derive_returnValue">
|
|
|
- /// The newly-defined class.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- if (baseClass) {
|
|
|
- constructor = constructor || function () { };
|
|
|
- var basePrototype = baseClass.prototype;
|
|
|
- constructor.prototype = Object.create(basePrototype);
|
|
|
- _BaseCoreUtils.markSupportedForProcessing(constructor);
|
|
|
- Object.defineProperty(constructor.prototype, "constructor", { value: constructor, writable: true, configurable: true, enumerable: true });
|
|
|
- if (instanceMembers) {
|
|
|
- initializeProperties(constructor.prototype, instanceMembers);
|
|
|
- }
|
|
|
- if (staticMembers) {
|
|
|
- initializeProperties(constructor, staticMembers);
|
|
|
- }
|
|
|
- return constructor;
|
|
|
- } else {
|
|
|
- return define(constructor, instanceMembers, staticMembers);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function mix(constructor) {
|
|
|
- /// <signature helpKeyword="WinJS.Class.mix">
|
|
|
- /// <summary locid="WinJS.Class.mix">
|
|
|
- /// Defines a class using the given constructor and the union of the set of instance members
|
|
|
- /// specified by all the mixin objects. The mixin parameter list is of variable length.
|
|
|
- /// </summary>
|
|
|
- /// <param name="constructor" locid="WinJS.Class.mix_p:constructor">
|
|
|
- /// A constructor function that is used to instantiate this class.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Function" locid="WinJS.Class.mix_returnValue">
|
|
|
- /// The newly-defined class.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- constructor = constructor || function () { };
|
|
|
- var i, len;
|
|
|
- for (i = 1, len = arguments.length; i < len; i++) {
|
|
|
- initializeProperties(constructor.prototype, arguments[i]);
|
|
|
- }
|
|
|
- return constructor;
|
|
|
- }
|
|
|
-
|
|
|
- // Establish members of "WinJS.Class" namespace
|
|
|
- _WinJS.Namespace.define("WinJS.Class", {
|
|
|
- define: define,
|
|
|
- derive: derive,
|
|
|
- mix: mix
|
|
|
- });
|
|
|
-
|
|
|
- })();
|
|
|
-
|
|
|
- return {
|
|
|
- Namespace: _WinJS.Namespace,
|
|
|
- Class: _WinJS.Class
|
|
|
- };
|
|
|
-
|
|
|
-});
|
|
|
-_winjs("WinJS/Core/_ErrorFromName", ["WinJS/Core/_Base"], function errorsInit(_Base) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- var ErrorFromName = _Base.Class.derive(Error, function (name, message) {
|
|
|
- /// <signature helpKeyword="WinJS.ErrorFromName">
|
|
|
- /// <summary locid="WinJS.ErrorFromName">
|
|
|
- /// Creates an Error object with the specified name and message properties.
|
|
|
- /// </summary>
|
|
|
- /// <param name="name" type="String" locid="WinJS.ErrorFromName_p:name">The name of this error. The name is meant to be consumed programmatically and should not be localized.</param>
|
|
|
- /// <param name="message" type="String" optional="true" locid="WinJS.ErrorFromName_p:message">The message for this error. The message is meant to be consumed by humans and should be localized.</param>
|
|
|
- /// <returns type="Error" locid="WinJS.ErrorFromName_returnValue">Error instance with .name and .message properties populated</returns>
|
|
|
- /// </signature>
|
|
|
- this.name = name;
|
|
|
- this.message = message || name;
|
|
|
- }, {
|
|
|
- /* empty */
|
|
|
- }, {
|
|
|
- supportedForProcessing: false,
|
|
|
- });
|
|
|
-
|
|
|
- _Base.Namespace.define("WinJS", {
|
|
|
- // ErrorFromName establishes a simple pattern for returning error codes.
|
|
|
- //
|
|
|
- ErrorFromName: ErrorFromName
|
|
|
- });
|
|
|
-
|
|
|
- return ErrorFromName;
|
|
|
-
|
|
|
-});
|
|
|
-
|
|
|
-
|
|
|
-_winjs("WinJS/Core/_Events", ["exports","WinJS/Core/_Base"], function eventsInit(exports, _Base) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
-
|
|
|
- function createEventProperty(name) {
|
|
|
- var eventPropStateName = "_on" + name + "state";
|
|
|
-
|
|
|
- return {
|
|
|
- get: function () {
|
|
|
- var state = this[eventPropStateName];
|
|
|
- return state && state.userHandler;
|
|
|
- },
|
|
|
- set: function (handler) {
|
|
|
- var state = this[eventPropStateName];
|
|
|
- if (handler) {
|
|
|
- if (!state) {
|
|
|
- state = { wrapper: function (evt) { return state.userHandler(evt); }, userHandler: handler };
|
|
|
- Object.defineProperty(this, eventPropStateName, { value: state, enumerable: false, writable:true, configurable: true });
|
|
|
- this.addEventListener(name, state.wrapper, false);
|
|
|
- }
|
|
|
- state.userHandler = handler;
|
|
|
- } else if (state) {
|
|
|
- this.removeEventListener(name, state.wrapper, false);
|
|
|
- this[eventPropStateName] = null;
|
|
|
- }
|
|
|
- },
|
|
|
- enumerable: true
|
|
|
- };
|
|
|
- }
|
|
|
-
|
|
|
- function createEventProperties() {
|
|
|
- /// <signature helpKeyword="WinJS.Utilities.createEventProperties">
|
|
|
- /// <summary locid="WinJS.Utilities.createEventProperties">
|
|
|
- /// Creates an object that has one property for each name passed to the function.
|
|
|
- /// </summary>
|
|
|
- /// <param name="events" locid="WinJS.Utilities.createEventProperties_p:events">
|
|
|
- /// A variable list of property names.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Object" locid="WinJS.Utilities.createEventProperties_returnValue">
|
|
|
- /// The object with the specified properties. The names of the properties are prefixed with 'on'.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- var props = {};
|
|
|
- for (var i = 0, len = arguments.length; i < len; i++) {
|
|
|
- var name = arguments[i];
|
|
|
- props["on" + name] = createEventProperty(name);
|
|
|
- }
|
|
|
- return props;
|
|
|
- }
|
|
|
-
|
|
|
- var EventMixinEvent = _Base.Class.define(
|
|
|
- function EventMixinEvent_ctor(type, detail, target) {
|
|
|
- this.detail = detail;
|
|
|
- this.target = target;
|
|
|
- this.timeStamp = Date.now();
|
|
|
- this.type = type;
|
|
|
- },
|
|
|
- {
|
|
|
- bubbles: { value: false, writable: false },
|
|
|
- cancelable: { value: false, writable: false },
|
|
|
- currentTarget: {
|
|
|
- get: function () { return this.target; }
|
|
|
- },
|
|
|
- defaultPrevented: {
|
|
|
- get: function () { return this._preventDefaultCalled; }
|
|
|
- },
|
|
|
- trusted: { value: false, writable: false },
|
|
|
- eventPhase: { value: 0, writable: false },
|
|
|
- target: null,
|
|
|
- timeStamp: null,
|
|
|
- type: null,
|
|
|
-
|
|
|
- preventDefault: function () {
|
|
|
- this._preventDefaultCalled = true;
|
|
|
- },
|
|
|
- stopImmediatePropagation: function () {
|
|
|
- this._stopImmediatePropagationCalled = true;
|
|
|
- },
|
|
|
- stopPropagation: function () {
|
|
|
- }
|
|
|
- }, {
|
|
|
- supportedForProcessing: false,
|
|
|
- }
|
|
|
- );
|
|
|
-
|
|
|
- var eventMixin = {
|
|
|
- _listeners: null,
|
|
|
-
|
|
|
- addEventListener: function (type, listener, useCapture) {
|
|
|
- /// <signature helpKeyword="WinJS.Utilities.eventMixin.addEventListener">
|
|
|
- /// <summary locid="WinJS.Utilities.eventMixin.addEventListener">
|
|
|
- /// Adds an event listener to the control.
|
|
|
- /// </summary>
|
|
|
- /// <param name="type" locid="WinJS.Utilities.eventMixin.addEventListener_p:type">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name="listener" locid="WinJS.Utilities.eventMixin.addEventListener_p:listener">
|
|
|
- /// The listener to invoke when the event is raised.
|
|
|
- /// </param>
|
|
|
- /// <param name="useCapture" locid="WinJS.Utilities.eventMixin.addEventListener_p:useCapture">
|
|
|
- /// if true initiates capture, otherwise false.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- useCapture = useCapture || false;
|
|
|
- this._listeners = this._listeners || {};
|
|
|
- var eventListeners = (this._listeners[type] = this._listeners[type] || []);
|
|
|
- for (var i = 0, len = eventListeners.length; i < len; i++) {
|
|
|
- var l = eventListeners[i];
|
|
|
- if (l.useCapture === useCapture && l.listener === listener) {
|
|
|
- return;
|
|
|
- }
|
|
|
- }
|
|
|
- eventListeners.push({ listener: listener, useCapture: useCapture });
|
|
|
- },
|
|
|
- dispatchEvent: function (type, details) {
|
|
|
- /// <signature helpKeyword="WinJS.Utilities.eventMixin.dispatchEvent">
|
|
|
- /// <summary locid="WinJS.Utilities.eventMixin.dispatchEvent">
|
|
|
- /// Raises an event of the specified type and with the specified additional properties.
|
|
|
- /// </summary>
|
|
|
- /// <param name="type" locid="WinJS.Utilities.eventMixin.dispatchEvent_p:type">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name="details" locid="WinJS.Utilities.eventMixin.dispatchEvent_p:details">
|
|
|
- /// The set of additional properties to be attached to the event object when the event is raised.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Boolean" locid="WinJS.Utilities.eventMixin.dispatchEvent_returnValue">
|
|
|
- /// true if preventDefault was called on the event.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- var listeners = this._listeners && this._listeners[type];
|
|
|
- if (listeners) {
|
|
|
- var eventValue = new EventMixinEvent(type, details, this);
|
|
|
- // Need to copy the array to protect against people unregistering while we are dispatching
|
|
|
- listeners = listeners.slice(0, listeners.length);
|
|
|
- for (var i = 0, len = listeners.length; i < len && !eventValue._stopImmediatePropagationCalled; i++) {
|
|
|
- listeners[i].listener(eventValue);
|
|
|
- }
|
|
|
- return eventValue.defaultPrevented || false;
|
|
|
- }
|
|
|
- return false;
|
|
|
- },
|
|
|
- removeEventListener: function (type, listener, useCapture) {
|
|
|
- /// <signature helpKeyword="WinJS.Utilities.eventMixin.removeEventListener">
|
|
|
- /// <summary locid="WinJS.Utilities.eventMixin.removeEventListener">
|
|
|
- /// Removes an event listener from the control.
|
|
|
- /// </summary>
|
|
|
- /// <param name="type" locid="WinJS.Utilities.eventMixin.removeEventListener_p:type">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name="listener" locid="WinJS.Utilities.eventMixin.removeEventListener_p:listener">
|
|
|
- /// The listener to remove.
|
|
|
- /// </param>
|
|
|
- /// <param name="useCapture" locid="WinJS.Utilities.eventMixin.removeEventListener_p:useCapture">
|
|
|
- /// Specifies whether to initiate capture.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- useCapture = useCapture || false;
|
|
|
- var listeners = this._listeners && this._listeners[type];
|
|
|
- if (listeners) {
|
|
|
- for (var i = 0, len = listeners.length; i < len; i++) {
|
|
|
- var l = listeners[i];
|
|
|
- if (l.listener === listener && l.useCapture === useCapture) {
|
|
|
- listeners.splice(i, 1);
|
|
|
- if (listeners.length === 0) {
|
|
|
- delete this._listeners[type];
|
|
|
- }
|
|
|
- // Only want to remove one element for each call to removeEventListener
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- _Base.Namespace._moduleDefine(exports, "WinJS.Utilities", {
|
|
|
- _createEventProperty: createEventProperty,
|
|
|
- createEventProperties: createEventProperties,
|
|
|
- eventMixin: eventMixin
|
|
|
- });
|
|
|
-
|
|
|
-});
|
|
|
-
|
|
|
-
|
|
|
-_winjs("WinJS/Core/_Trace", ["WinJS/Core/_Global"], function traceInit(_Global) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- function nop(v) {
|
|
|
- return v;
|
|
|
- }
|
|
|
-
|
|
|
- return {
|
|
|
- _traceAsyncOperationStarting: (_Global.Debug && _Global.Debug.msTraceAsyncOperationStarting && _Global.Debug.msTraceAsyncOperationStarting.bind(_Global.Debug)) || nop,
|
|
|
- _traceAsyncOperationCompleted: (_Global.Debug && _Global.Debug.msTraceAsyncOperationCompleted && _Global.Debug.msTraceAsyncOperationCompleted.bind(_Global.Debug)) || nop,
|
|
|
- _traceAsyncCallbackStarting: (_Global.Debug && _Global.Debug.msTraceAsyncCallbackStarting && _Global.Debug.msTraceAsyncCallbackStarting.bind(_Global.Debug)) || nop,
|
|
|
- _traceAsyncCallbackCompleted: (_Global.Debug && _Global.Debug.msTraceAsyncCallbackCompleted && _Global.Debug.msTraceAsyncCallbackCompleted.bind(_Global.Debug)) || nop
|
|
|
- };
|
|
|
-});
|
|
|
-_winjs("WinJS/Promise/_StateMachine", ["WinJS/Core/_Global","WinJS/Core/_BaseCoreUtils","WinJS/Core/_Base","WinJS/Core/_ErrorFromName","WinJS/Core/_Events","WinJS/Core/_Trace"], function promiseStateMachineInit(_Global, _BaseCoreUtils, _Base, _ErrorFromName, _Events, _Trace) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- _Global.Debug && (_Global.Debug.setNonUserCodeExceptions = true);
|
|
|
-
|
|
|
- var ListenerType = _Base.Class.mix(_Base.Class.define(null, { /*empty*/ }, { supportedForProcessing: false }), _Events.eventMixin);
|
|
|
- var promiseEventListeners = new ListenerType();
|
|
|
- // make sure there is a listeners collection so that we can do a more trivial check below
|
|
|
- promiseEventListeners._listeners = {};
|
|
|
- var errorET = "error";
|
|
|
- var canceledName = "Canceled";
|
|
|
- var tagWithStack = false;
|
|
|
- var tag = {
|
|
|
- promise: 0x01,
|
|
|
- thenPromise: 0x02,
|
|
|
- errorPromise: 0x04,
|
|
|
- exceptionPromise: 0x08,
|
|
|
- completePromise: 0x10,
|
|
|
- };
|
|
|
- tag.all = tag.promise | tag.thenPromise | tag.errorPromise | tag.exceptionPromise | tag.completePromise;
|
|
|
-
|
|
|
- //
|
|
|
- // Global error counter, for each error which enters the system we increment this once and then
|
|
|
- // the error number travels with the error as it traverses the tree of potential handlers.
|
|
|
- //
|
|
|
- // When someone has registered to be told about errors (WinJS.Promise.callonerror) promises
|
|
|
- // which are in error will get tagged with a ._errorId field. This tagged field is the
|
|
|
- // contract by which nested promises with errors will be identified as chaining for the
|
|
|
- // purposes of the callonerror semantics. If a nested promise in error is encountered without
|
|
|
- // a ._errorId it will be assumed to be foreign and treated as an interop boundary and
|
|
|
- // a new error id will be minted.
|
|
|
- //
|
|
|
- var error_number = 1;
|
|
|
-
|
|
|
- //
|
|
|
- // The state machine has a interesting hiccup in it with regards to notification, in order
|
|
|
- // to flatten out notification and avoid recursion for synchronous completion we have an
|
|
|
- // explicit set of *_notify states which are responsible for notifying their entire tree
|
|
|
- // of children. They can do this because they know that immediate children are always
|
|
|
- // ThenPromise instances and we can therefore reach into their state to access the
|
|
|
- // _listeners collection.
|
|
|
- //
|
|
|
- // So, what happens is that a Promise will be fulfilled through the _completed or _error
|
|
|
- // messages at which point it will enter a *_notify state and be responsible for to move
|
|
|
- // its children into an (as appropriate) success or error state and also notify that child's
|
|
|
- // listeners of the state transition, until leaf notes are reached.
|
|
|
- //
|
|
|
-
|
|
|
- var state_created, // -> working
|
|
|
- state_working, // -> error | error_notify | success | success_notify | canceled | waiting
|
|
|
- state_waiting, // -> error | error_notify | success | success_notify | waiting_canceled
|
|
|
- state_waiting_canceled, // -> error | error_notify | success | success_notify | canceling
|
|
|
- state_canceled, // -> error | error_notify | success | success_notify | canceling
|
|
|
- state_canceling, // -> error_notify
|
|
|
- state_success_notify, // -> success
|
|
|
- state_success, // -> .
|
|
|
- state_error_notify, // -> error
|
|
|
- state_error; // -> .
|
|
|
-
|
|
|
- // Noop function, used in the various states to indicate that they don't support a given
|
|
|
- // message. Named with the somewhat cute name '_' because it reads really well in the states.
|
|
|
-
|
|
|
- function _() { }
|
|
|
-
|
|
|
- // Initial state
|
|
|
- //
|
|
|
- state_created = {
|
|
|
- name: "created",
|
|
|
- enter: function (promise) {
|
|
|
- promise._setState(state_working);
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: _,
|
|
|
- then: _,
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: _,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- // Ready state, waiting for a message (completed/error/progress), able to be canceled
|
|
|
- //
|
|
|
- state_working = {
|
|
|
- name: "working",
|
|
|
- enter: _,
|
|
|
- cancel: function (promise) {
|
|
|
- promise._setState(state_canceled);
|
|
|
- },
|
|
|
- done: done,
|
|
|
- then: then,
|
|
|
- _completed: completed,
|
|
|
- _error: error,
|
|
|
- _notify: _,
|
|
|
- _progress: progress,
|
|
|
- _setCompleteValue: setCompleteValue,
|
|
|
- _setErrorValue: setErrorValue
|
|
|
- };
|
|
|
-
|
|
|
- // Waiting state, if a promise is completed with a value which is itself a promise
|
|
|
- // (has a then() method) it signs up to be informed when that child promise is
|
|
|
- // fulfilled at which point it will be fulfilled with that value.
|
|
|
- //
|
|
|
- state_waiting = {
|
|
|
- name: "waiting",
|
|
|
- enter: function (promise) {
|
|
|
- var waitedUpon = promise._value;
|
|
|
- // We can special case our own intermediate promises which are not in a
|
|
|
- // terminal state by just pushing this promise as a listener without
|
|
|
- // having to create new indirection functions
|
|
|
- if (waitedUpon instanceof ThenPromise &&
|
|
|
- waitedUpon._state !== state_error &&
|
|
|
- waitedUpon._state !== state_success) {
|
|
|
- pushListener(waitedUpon, { promise: promise });
|
|
|
- } else {
|
|
|
- var error = function (value) {
|
|
|
- if (waitedUpon._errorId) {
|
|
|
- promise._chainedError(value, waitedUpon);
|
|
|
- } else {
|
|
|
- // Because this is an interop boundary we want to indicate that this
|
|
|
- // error has been handled by the promise infrastructure before we
|
|
|
- // begin a new handling chain.
|
|
|
- //
|
|
|
- callonerror(promise, value, detailsForHandledError, waitedUpon, error);
|
|
|
- promise._error(value);
|
|
|
- }
|
|
|
- };
|
|
|
- error.handlesOnError = true;
|
|
|
- waitedUpon.then(
|
|
|
- promise._completed.bind(promise),
|
|
|
- error,
|
|
|
- promise._progress.bind(promise)
|
|
|
- );
|
|
|
- }
|
|
|
- },
|
|
|
- cancel: function (promise) {
|
|
|
- promise._setState(state_waiting_canceled);
|
|
|
- },
|
|
|
- done: done,
|
|
|
- then: then,
|
|
|
- _completed: completed,
|
|
|
- _error: error,
|
|
|
- _notify: _,
|
|
|
- _progress: progress,
|
|
|
- _setCompleteValue: setCompleteValue,
|
|
|
- _setErrorValue: setErrorValue
|
|
|
- };
|
|
|
-
|
|
|
- // Waiting canceled state, when a promise has been in a waiting state and receives a
|
|
|
- // request to cancel its pending work it will forward that request to the child promise
|
|
|
- // and then waits to be informed of the result. This promise moves itself into the
|
|
|
- // canceling state but understands that the child promise may instead push it to a
|
|
|
- // different state.
|
|
|
- //
|
|
|
- state_waiting_canceled = {
|
|
|
- name: "waiting_canceled",
|
|
|
- enter: function (promise) {
|
|
|
- // Initiate a transition to canceling. Triggering a cancel on the promise
|
|
|
- // that we are waiting upon may result in a different state transition
|
|
|
- // before the state machine pump runs again.
|
|
|
- promise._setState(state_canceling);
|
|
|
- var waitedUpon = promise._value;
|
|
|
- if (waitedUpon.cancel) {
|
|
|
- waitedUpon.cancel();
|
|
|
- }
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: done,
|
|
|
- then: then,
|
|
|
- _completed: completed,
|
|
|
- _error: error,
|
|
|
- _notify: _,
|
|
|
- _progress: progress,
|
|
|
- _setCompleteValue: setCompleteValue,
|
|
|
- _setErrorValue: setErrorValue
|
|
|
- };
|
|
|
-
|
|
|
- // Canceled state, moves to the canceling state and then tells the promise to do
|
|
|
- // whatever it might need to do on cancelation.
|
|
|
- //
|
|
|
- state_canceled = {
|
|
|
- name: "canceled",
|
|
|
- enter: function (promise) {
|
|
|
- // Initiate a transition to canceling. The _cancelAction may change the state
|
|
|
- // before the state machine pump runs again.
|
|
|
- promise._setState(state_canceling);
|
|
|
- promise._cancelAction();
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: done,
|
|
|
- then: then,
|
|
|
- _completed: completed,
|
|
|
- _error: error,
|
|
|
- _notify: _,
|
|
|
- _progress: progress,
|
|
|
- _setCompleteValue: setCompleteValue,
|
|
|
- _setErrorValue: setErrorValue
|
|
|
- };
|
|
|
-
|
|
|
- // Canceling state, commits to the promise moving to an error state with an error
|
|
|
- // object whose 'name' and 'message' properties contain the string "Canceled"
|
|
|
- //
|
|
|
- state_canceling = {
|
|
|
- name: "canceling",
|
|
|
- enter: function (promise) {
|
|
|
- var error = new Error(canceledName);
|
|
|
- error.name = error.message;
|
|
|
- promise._value = error;
|
|
|
- promise._setState(state_error_notify);
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: _,
|
|
|
- then: _,
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: _,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- // Success notify state, moves a promise to the success state and notifies all children
|
|
|
- //
|
|
|
- state_success_notify = {
|
|
|
- name: "complete_notify",
|
|
|
- enter: function (promise) {
|
|
|
- promise.done = CompletePromise.prototype.done;
|
|
|
- promise.then = CompletePromise.prototype.then;
|
|
|
- if (promise._listeners) {
|
|
|
- var queue = [promise];
|
|
|
- var p;
|
|
|
- while (queue.length) {
|
|
|
- p = queue.shift();
|
|
|
- p._state._notify(p, queue);
|
|
|
- }
|
|
|
- }
|
|
|
- promise._setState(state_success);
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: null, /*error to get here */
|
|
|
- then: null, /*error to get here */
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: notifySuccess,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- // Success state, moves a promise to the success state and does NOT notify any children.
|
|
|
- // Some upstream promise is owning the notification pass.
|
|
|
- //
|
|
|
- state_success = {
|
|
|
- name: "success",
|
|
|
- enter: function (promise) {
|
|
|
- promise.done = CompletePromise.prototype.done;
|
|
|
- promise.then = CompletePromise.prototype.then;
|
|
|
- promise._cleanupAction();
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: null, /*error to get here */
|
|
|
- then: null, /*error to get here */
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: notifySuccess,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- // Error notify state, moves a promise to the error state and notifies all children
|
|
|
- //
|
|
|
- state_error_notify = {
|
|
|
- name: "error_notify",
|
|
|
- enter: function (promise) {
|
|
|
- promise.done = ErrorPromise.prototype.done;
|
|
|
- promise.then = ErrorPromise.prototype.then;
|
|
|
- if (promise._listeners) {
|
|
|
- var queue = [promise];
|
|
|
- var p;
|
|
|
- while (queue.length) {
|
|
|
- p = queue.shift();
|
|
|
- p._state._notify(p, queue);
|
|
|
- }
|
|
|
- }
|
|
|
- promise._setState(state_error);
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: null, /*error to get here*/
|
|
|
- then: null, /*error to get here*/
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: notifyError,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- // Error state, moves a promise to the error state and does NOT notify any children.
|
|
|
- // Some upstream promise is owning the notification pass.
|
|
|
- //
|
|
|
- state_error = {
|
|
|
- name: "error",
|
|
|
- enter: function (promise) {
|
|
|
- promise.done = ErrorPromise.prototype.done;
|
|
|
- promise.then = ErrorPromise.prototype.then;
|
|
|
- promise._cleanupAction();
|
|
|
- },
|
|
|
- cancel: _,
|
|
|
- done: null, /*error to get here*/
|
|
|
- then: null, /*error to get here*/
|
|
|
- _completed: _,
|
|
|
- _error: _,
|
|
|
- _notify: notifyError,
|
|
|
- _progress: _,
|
|
|
- _setCompleteValue: _,
|
|
|
- _setErrorValue: _
|
|
|
- };
|
|
|
-
|
|
|
- //
|
|
|
- // The statemachine implementation follows a very particular pattern, the states are specified
|
|
|
- // as static stateless bags of functions which are then indirected through the state machine
|
|
|
- // instance (a Promise). As such all of the functions on each state have the promise instance
|
|
|
- // passed to them explicitly as a parameter and the Promise instance members do a little
|
|
|
- // dance where they indirect through the state and insert themselves in the argument list.
|
|
|
- //
|
|
|
- // We could instead call directly through the promise states however then every caller
|
|
|
- // would have to remember to do things like pumping the state machine to catch state transitions.
|
|
|
- //
|
|
|
-
|
|
|
- var PromiseStateMachine = _Base.Class.define(null, {
|
|
|
- _listeners: null,
|
|
|
- _nextState: null,
|
|
|
- _state: null,
|
|
|
- _value: null,
|
|
|
-
|
|
|
- cancel: function () {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't
|
|
|
- /// already been fulfilled and cancellation is supported, the promise enters
|
|
|
- /// the error state with a value of Error("Canceled").
|
|
|
- /// </summary>
|
|
|
- /// </signature>
|
|
|
- this._state.cancel(this);
|
|
|
- this._run();
|
|
|
- },
|
|
|
- done: function Promise_done(onComplete, onError, onProgress) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.done">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.done">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- ///
|
|
|
- /// After the handlers have finished executing, this function throws any error that would have been returned
|
|
|
- /// from then() as a promise in the error state.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.done_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The fulfilled value is passed as the single argument. If the value is null,
|
|
|
- /// the fulfilled value is returned. The value returned
|
|
|
- /// from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while executing the function, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function is the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onProgress">
|
|
|
- /// the function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- this._state.done(this, onComplete, onError, onProgress);
|
|
|
- },
|
|
|
- then: function Promise_then(onComplete, onError, onProgress) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.then">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.then">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.then_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The value is passed as the single argument. If the value is null, the value is returned.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while this function is being executed, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onProgress">
|
|
|
- /// The function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.PromiseStateMachine.then_returnValue">
|
|
|
- /// The promise whose value is the result of executing the complete or
|
|
|
- /// error function.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return this._state.then(this, onComplete, onError, onProgress);
|
|
|
- },
|
|
|
-
|
|
|
- _chainedError: function (value, context) {
|
|
|
- var result = this._state._error(this, value, detailsForChainedError, context);
|
|
|
- this._run();
|
|
|
- return result;
|
|
|
- },
|
|
|
- _completed: function (value) {
|
|
|
- var result = this._state._completed(this, value);
|
|
|
- this._run();
|
|
|
- return result;
|
|
|
- },
|
|
|
- _error: function (value) {
|
|
|
- var result = this._state._error(this, value, detailsForError);
|
|
|
- this._run();
|
|
|
- return result;
|
|
|
- },
|
|
|
- _progress: function (value) {
|
|
|
- this._state._progress(this, value);
|
|
|
- },
|
|
|
- _setState: function (state) {
|
|
|
- this._nextState = state;
|
|
|
- },
|
|
|
- _setCompleteValue: function (value) {
|
|
|
- this._state._setCompleteValue(this, value);
|
|
|
- this._run();
|
|
|
- },
|
|
|
- _setChainedErrorValue: function (value, context) {
|
|
|
- var result = this._state._setErrorValue(this, value, detailsForChainedError, context);
|
|
|
- this._run();
|
|
|
- return result;
|
|
|
- },
|
|
|
- _setExceptionValue: function (value) {
|
|
|
- var result = this._state._setErrorValue(this, value, detailsForException);
|
|
|
- this._run();
|
|
|
- return result;
|
|
|
- },
|
|
|
- _run: function () {
|
|
|
- while (this._nextState) {
|
|
|
- this._state = this._nextState;
|
|
|
- this._nextState = null;
|
|
|
- this._state.enter(this);
|
|
|
- }
|
|
|
- }
|
|
|
- }, {
|
|
|
- supportedForProcessing: false
|
|
|
- });
|
|
|
-
|
|
|
- //
|
|
|
- // Implementations of shared state machine code.
|
|
|
- //
|
|
|
-
|
|
|
- function completed(promise, value) {
|
|
|
- var targetState;
|
|
|
- if (value && typeof value === "object" && typeof value.then === "function") {
|
|
|
- targetState = state_waiting;
|
|
|
- } else {
|
|
|
- targetState = state_success_notify;
|
|
|
- }
|
|
|
- promise._value = value;
|
|
|
- promise._setState(targetState);
|
|
|
- }
|
|
|
- function createErrorDetails(exception, error, promise, id, parent, handler) {
|
|
|
- return {
|
|
|
- exception: exception,
|
|
|
- error: error,
|
|
|
- promise: promise,
|
|
|
- handler: handler,
|
|
|
- id: id,
|
|
|
- parent: parent
|
|
|
- };
|
|
|
- }
|
|
|
- function detailsForHandledError(promise, errorValue, context, handler) {
|
|
|
- var exception = context._isException;
|
|
|
- var errorId = context._errorId;
|
|
|
- return createErrorDetails(
|
|
|
- exception ? errorValue : null,
|
|
|
- exception ? null : errorValue,
|
|
|
- promise,
|
|
|
- errorId,
|
|
|
- context,
|
|
|
- handler
|
|
|
- );
|
|
|
- }
|
|
|
- function detailsForChainedError(promise, errorValue, context) {
|
|
|
- var exception = context._isException;
|
|
|
- var errorId = context._errorId;
|
|
|
- setErrorInfo(promise, errorId, exception);
|
|
|
- return createErrorDetails(
|
|
|
- exception ? errorValue : null,
|
|
|
- exception ? null : errorValue,
|
|
|
- promise,
|
|
|
- errorId,
|
|
|
- context
|
|
|
- );
|
|
|
- }
|
|
|
- function detailsForError(promise, errorValue) {
|
|
|
- var errorId = ++error_number;
|
|
|
- setErrorInfo(promise, errorId);
|
|
|
- return createErrorDetails(
|
|
|
- null,
|
|
|
- errorValue,
|
|
|
- promise,
|
|
|
- errorId
|
|
|
- );
|
|
|
- }
|
|
|
- function detailsForException(promise, exceptionValue) {
|
|
|
- var errorId = ++error_number;
|
|
|
- setErrorInfo(promise, errorId, true);
|
|
|
- return createErrorDetails(
|
|
|
- exceptionValue,
|
|
|
- null,
|
|
|
- promise,
|
|
|
- errorId
|
|
|
- );
|
|
|
- }
|
|
|
- function done(promise, onComplete, onError, onProgress) {
|
|
|
- var asyncOpID = _Trace._traceAsyncOperationStarting("WinJS.Promise.done");
|
|
|
- pushListener(promise, { c: onComplete, e: onError, p: onProgress, asyncOpID: asyncOpID });
|
|
|
- }
|
|
|
- function error(promise, value, onerrorDetails, context) {
|
|
|
- promise._value = value;
|
|
|
- callonerror(promise, value, onerrorDetails, context);
|
|
|
- promise._setState(state_error_notify);
|
|
|
- }
|
|
|
- function notifySuccess(promise, queue) {
|
|
|
- var value = promise._value;
|
|
|
- var listeners = promise._listeners;
|
|
|
- if (!listeners) {
|
|
|
- return;
|
|
|
- }
|
|
|
- promise._listeners = null;
|
|
|
- var i, len;
|
|
|
- for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {
|
|
|
- var listener = len === 1 ? listeners : listeners[i];
|
|
|
- var onComplete = listener.c;
|
|
|
- var target = listener.promise;
|
|
|
-
|
|
|
- _Trace._traceAsyncOperationCompleted(listener.asyncOpID, _Global.Debug && _Global.Debug.MS_ASYNC_OP_STATUS_SUCCESS);
|
|
|
-
|
|
|
- if (target) {
|
|
|
- _Trace._traceAsyncCallbackStarting(listener.asyncOpID);
|
|
|
- try {
|
|
|
- target._setCompleteValue(onComplete ? onComplete(value) : value);
|
|
|
- } catch (ex) {
|
|
|
- target._setExceptionValue(ex);
|
|
|
- } finally {
|
|
|
- _Trace._traceAsyncCallbackCompleted();
|
|
|
- }
|
|
|
- if (target._state !== state_waiting && target._listeners) {
|
|
|
- queue.push(target);
|
|
|
- }
|
|
|
- } else {
|
|
|
- CompletePromise.prototype.done.call(promise, onComplete);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- function notifyError(promise, queue) {
|
|
|
- var value = promise._value;
|
|
|
- var listeners = promise._listeners;
|
|
|
- if (!listeners) {
|
|
|
- return;
|
|
|
- }
|
|
|
- promise._listeners = null;
|
|
|
- var i, len;
|
|
|
- for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {
|
|
|
- var listener = len === 1 ? listeners : listeners[i];
|
|
|
- var onError = listener.e;
|
|
|
- var target = listener.promise;
|
|
|
-
|
|
|
- var errorID = _Global.Debug && (value && value.name === canceledName ? _Global.Debug.MS_ASYNC_OP_STATUS_CANCELED : _Global.Debug.MS_ASYNC_OP_STATUS_ERROR);
|
|
|
- _Trace._traceAsyncOperationCompleted(listener.asyncOpID, errorID);
|
|
|
-
|
|
|
- if (target) {
|
|
|
- var asyncCallbackStarted = false;
|
|
|
- try {
|
|
|
- if (onError) {
|
|
|
- _Trace._traceAsyncCallbackStarting(listener.asyncOpID);
|
|
|
- asyncCallbackStarted = true;
|
|
|
- if (!onError.handlesOnError) {
|
|
|
- callonerror(target, value, detailsForHandledError, promise, onError);
|
|
|
- }
|
|
|
- target._setCompleteValue(onError(value));
|
|
|
- } else {
|
|
|
- target._setChainedErrorValue(value, promise);
|
|
|
- }
|
|
|
- } catch (ex) {
|
|
|
- target._setExceptionValue(ex);
|
|
|
- } finally {
|
|
|
- if (asyncCallbackStarted) {
|
|
|
- _Trace._traceAsyncCallbackCompleted();
|
|
|
- }
|
|
|
- }
|
|
|
- if (target._state !== state_waiting && target._listeners) {
|
|
|
- queue.push(target);
|
|
|
- }
|
|
|
- } else {
|
|
|
- ErrorPromise.prototype.done.call(promise, null, onError);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- function callonerror(promise, value, onerrorDetailsGenerator, context, handler) {
|
|
|
- if (promiseEventListeners._listeners[errorET]) {
|
|
|
- if (value instanceof Error && value.message === canceledName) {
|
|
|
- return;
|
|
|
- }
|
|
|
- promiseEventListeners.dispatchEvent(errorET, onerrorDetailsGenerator(promise, value, context, handler));
|
|
|
- }
|
|
|
- }
|
|
|
- function progress(promise, value) {
|
|
|
- var listeners = promise._listeners;
|
|
|
- if (listeners) {
|
|
|
- var i, len;
|
|
|
- for (i = 0, len = Array.isArray(listeners) ? listeners.length : 1; i < len; i++) {
|
|
|
- var listener = len === 1 ? listeners : listeners[i];
|
|
|
- var onProgress = listener.p;
|
|
|
- if (onProgress) {
|
|
|
- try { onProgress(value); } catch (ex) { }
|
|
|
- }
|
|
|
- if (!(listener.c || listener.e) && listener.promise) {
|
|
|
- listener.promise._progress(value);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- function pushListener(promise, listener) {
|
|
|
- var listeners = promise._listeners;
|
|
|
- if (listeners) {
|
|
|
- // We may have either a single listener (which will never be wrapped in an array)
|
|
|
- // or 2+ listeners (which will be wrapped). Since we are now adding one more listener
|
|
|
- // we may have to wrap the single listener before adding the second.
|
|
|
- listeners = Array.isArray(listeners) ? listeners : [listeners];
|
|
|
- listeners.push(listener);
|
|
|
- } else {
|
|
|
- listeners = listener;
|
|
|
- }
|
|
|
- promise._listeners = listeners;
|
|
|
- }
|
|
|
- // The difference beween setCompleteValue()/setErrorValue() and complete()/error() is that setXXXValue() moves
|
|
|
- // a promise directly to the success/error state without starting another notification pass (because one
|
|
|
- // is already ongoing).
|
|
|
- function setErrorInfo(promise, errorId, isException) {
|
|
|
- promise._isException = isException || false;
|
|
|
- promise._errorId = errorId;
|
|
|
- }
|
|
|
- function setErrorValue(promise, value, onerrorDetails, context) {
|
|
|
- promise._value = value;
|
|
|
- callonerror(promise, value, onerrorDetails, context);
|
|
|
- promise._setState(state_error);
|
|
|
- }
|
|
|
- function setCompleteValue(promise, value) {
|
|
|
- var targetState;
|
|
|
- if (value && typeof value === "object" && typeof value.then === "function") {
|
|
|
- targetState = state_waiting;
|
|
|
- } else {
|
|
|
- targetState = state_success;
|
|
|
- }
|
|
|
- promise._value = value;
|
|
|
- promise._setState(targetState);
|
|
|
- }
|
|
|
- function then(promise, onComplete, onError, onProgress) {
|
|
|
- var result = new ThenPromise(promise);
|
|
|
- var asyncOpID = _Trace._traceAsyncOperationStarting("WinJS.Promise.then");
|
|
|
- pushListener(promise, { promise: result, c: onComplete, e: onError, p: onProgress, asyncOpID: asyncOpID });
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- //
|
|
|
- // Internal implementation detail promise, ThenPromise is created when a promise needs
|
|
|
- // to be returned from a then() method.
|
|
|
- //
|
|
|
- var ThenPromise = _Base.Class.derive(PromiseStateMachine,
|
|
|
- function (creator) {
|
|
|
-
|
|
|
- if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.thenPromise))) {
|
|
|
- this._stack = Promise._getStack();
|
|
|
- }
|
|
|
-
|
|
|
- this._creator = creator;
|
|
|
- this._setState(state_created);
|
|
|
- this._run();
|
|
|
- }, {
|
|
|
- _creator: null,
|
|
|
-
|
|
|
- _cancelAction: function () { if (this._creator) { this._creator.cancel(); } },
|
|
|
- _cleanupAction: function () { this._creator = null; }
|
|
|
- }, {
|
|
|
- supportedForProcessing: false
|
|
|
- }
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // Slim promise implementations for already completed promises, these are created
|
|
|
- // under the hood on synchronous completion paths as well as by WinJS.Promise.wrap
|
|
|
- // and WinJS.Promise.wrapError.
|
|
|
- //
|
|
|
-
|
|
|
- var ErrorPromise = _Base.Class.define(
|
|
|
- function ErrorPromise_ctor(value) {
|
|
|
-
|
|
|
- if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.errorPromise))) {
|
|
|
- this._stack = Promise._getStack();
|
|
|
- }
|
|
|
-
|
|
|
- this._value = value;
|
|
|
- callonerror(this, value, detailsForError);
|
|
|
- }, {
|
|
|
- cancel: function () {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't
|
|
|
- /// already been fulfilled and cancellation is supported, the promise enters
|
|
|
- /// the error state with a value of Error("Canceled").
|
|
|
- /// </summary>
|
|
|
- /// </signature>
|
|
|
- },
|
|
|
- done: function ErrorPromise_done(unused, onError) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.done">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.done">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- ///
|
|
|
- /// After the handlers have finished executing, this function throws any error that would have been returned
|
|
|
- /// from then() as a promise in the error state.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.done_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The fulfilled value is passed as the single argument. If the value is null,
|
|
|
- /// the fulfilled value is returned. The value returned
|
|
|
- /// from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while executing the function, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function is the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onProgress">
|
|
|
- /// the function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- var value = this._value;
|
|
|
- if (onError) {
|
|
|
- try {
|
|
|
- if (!onError.handlesOnError) {
|
|
|
- callonerror(null, value, detailsForHandledError, this, onError);
|
|
|
- }
|
|
|
- var result = onError(value);
|
|
|
- if (result && typeof result === "object" && typeof result.done === "function") {
|
|
|
- // If a promise is returned we need to wait on it.
|
|
|
- result.done();
|
|
|
- }
|
|
|
- return;
|
|
|
- } catch (ex) {
|
|
|
- value = ex;
|
|
|
- }
|
|
|
- }
|
|
|
- if (value instanceof Error && value.message === canceledName) {
|
|
|
- // suppress cancel
|
|
|
- return;
|
|
|
- }
|
|
|
- // force the exception to be thrown asyncronously to avoid any try/catch blocks
|
|
|
- //
|
|
|
- Promise._doneHandler(value);
|
|
|
- },
|
|
|
- then: function ErrorPromise_then(unused, onError) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.then">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.then">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.then_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The value is passed as the single argument. If the value is null, the value is returned.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while this function is being executed, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onProgress">
|
|
|
- /// The function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.PromiseStateMachine.then_returnValue">
|
|
|
- /// The promise whose value is the result of executing the complete or
|
|
|
- /// error function.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
-
|
|
|
- // If the promise is already in a error state and no error handler is provided
|
|
|
- // we optimize by simply returning the promise instead of creating a new one.
|
|
|
- //
|
|
|
- if (!onError) { return this; }
|
|
|
- var result;
|
|
|
- var value = this._value;
|
|
|
- try {
|
|
|
- if (!onError.handlesOnError) {
|
|
|
- callonerror(null, value, detailsForHandledError, this, onError);
|
|
|
- }
|
|
|
- result = new CompletePromise(onError(value));
|
|
|
- } catch (ex) {
|
|
|
- // If the value throw from the error handler is the same as the value
|
|
|
- // provided to the error handler then there is no need for a new promise.
|
|
|
- //
|
|
|
- if (ex === value) {
|
|
|
- result = this;
|
|
|
- } else {
|
|
|
- result = new ExceptionPromise(ex);
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- }, {
|
|
|
- supportedForProcessing: false
|
|
|
- }
|
|
|
- );
|
|
|
-
|
|
|
- var ExceptionPromise = _Base.Class.derive(ErrorPromise,
|
|
|
- function ExceptionPromise_ctor(value) {
|
|
|
-
|
|
|
- if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.exceptionPromise))) {
|
|
|
- this._stack = Promise._getStack();
|
|
|
- }
|
|
|
-
|
|
|
- this._value = value;
|
|
|
- callonerror(this, value, detailsForException);
|
|
|
- }, {
|
|
|
- /* empty */
|
|
|
- }, {
|
|
|
- supportedForProcessing: false
|
|
|
- }
|
|
|
- );
|
|
|
-
|
|
|
- var CompletePromise = _Base.Class.define(
|
|
|
- function CompletePromise_ctor(value) {
|
|
|
-
|
|
|
- if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.completePromise))) {
|
|
|
- this._stack = Promise._getStack();
|
|
|
- }
|
|
|
-
|
|
|
- if (value && typeof value === "object" && typeof value.then === "function") {
|
|
|
- var result = new ThenPromise(null);
|
|
|
- result._setCompleteValue(value);
|
|
|
- return result;
|
|
|
- }
|
|
|
- this._value = value;
|
|
|
- }, {
|
|
|
- cancel: function () {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.cancel">
|
|
|
- /// Attempts to cancel the fulfillment of a promised value. If the promise hasn't
|
|
|
- /// already been fulfilled and cancellation is supported, the promise enters
|
|
|
- /// the error state with a value of Error("Canceled").
|
|
|
- /// </summary>
|
|
|
- /// </signature>
|
|
|
- },
|
|
|
- done: function CompletePromise_done(onComplete) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.done">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.done">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- ///
|
|
|
- /// After the handlers have finished executing, this function throws any error that would have been returned
|
|
|
- /// from then() as a promise in the error state.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.done_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The fulfilled value is passed as the single argument. If the value is null,
|
|
|
- /// the fulfilled value is returned. The value returned
|
|
|
- /// from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while executing the function, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function is the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.done_p:onProgress">
|
|
|
- /// the function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- if (!onComplete) { return; }
|
|
|
- try {
|
|
|
- var result = onComplete(this._value);
|
|
|
- if (result && typeof result === "object" && typeof result.done === "function") {
|
|
|
- result.done();
|
|
|
- }
|
|
|
- } catch (ex) {
|
|
|
- // force the exception to be thrown asynchronously to avoid any try/catch blocks
|
|
|
- Promise._doneHandler(ex);
|
|
|
- }
|
|
|
- },
|
|
|
- then: function CompletePromise_then(onComplete) {
|
|
|
- /// <signature helpKeyword="WinJS.PromiseStateMachine.then">
|
|
|
- /// <summary locid="WinJS.PromiseStateMachine.then">
|
|
|
- /// Allows you to specify the work to be done on the fulfillment of the promised value,
|
|
|
- /// the error handling to be performed if the promise fails to fulfill
|
|
|
- /// a value, and the handling of progress notifications along the way.
|
|
|
- /// </summary>
|
|
|
- /// <param name='onComplete' type='Function' locid="WinJS.PromiseStateMachine.then_p:onComplete">
|
|
|
- /// The function to be called if the promise is fulfilled successfully with a value.
|
|
|
- /// The value is passed as the single argument. If the value is null, the value is returned.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by
|
|
|
- /// then(). If an exception is thrown while this function is being executed, the promise returned
|
|
|
- /// by then() moves into the error state.
|
|
|
- /// </param>
|
|
|
- /// <param name='onError' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onError">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument. If it is null, the error is forwarded.
|
|
|
- /// The value returned from the function becomes the fulfilled value of the promise returned by then().
|
|
|
- /// </param>
|
|
|
- /// <param name='onProgress' type='Function' optional='true' locid="WinJS.PromiseStateMachine.then_p:onProgress">
|
|
|
- /// The function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.PromiseStateMachine.then_returnValue">
|
|
|
- /// The promise whose value is the result of executing the complete or
|
|
|
- /// error function.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- try {
|
|
|
- // If the value returned from the completion handler is the same as the value
|
|
|
- // provided to the completion handler then there is no need for a new promise.
|
|
|
- //
|
|
|
- var newValue = onComplete ? onComplete(this._value) : this._value;
|
|
|
- return newValue === this._value ? this : new CompletePromise(newValue);
|
|
|
- } catch (ex) {
|
|
|
- return new ExceptionPromise(ex);
|
|
|
- }
|
|
|
- }
|
|
|
- }, {
|
|
|
- supportedForProcessing: false
|
|
|
- }
|
|
|
- );
|
|
|
-
|
|
|
- //
|
|
|
- // Promise is the user-creatable WinJS.Promise object.
|
|
|
- //
|
|
|
-
|
|
|
- function timeout(timeoutMS) {
|
|
|
- var id;
|
|
|
- return new Promise(
|
|
|
- function (c) {
|
|
|
- if (timeoutMS) {
|
|
|
- id = _Global.setTimeout(c, timeoutMS);
|
|
|
- } else {
|
|
|
- _BaseCoreUtils._setImmediate(c);
|
|
|
- }
|
|
|
- },
|
|
|
- function () {
|
|
|
- if (id) {
|
|
|
- _Global.clearTimeout(id);
|
|
|
- }
|
|
|
- }
|
|
|
- );
|
|
|
- }
|
|
|
-
|
|
|
- function timeoutWithPromise(timeout, promise) {
|
|
|
- var cancelPromise = function () { promise.cancel(); };
|
|
|
- var cancelTimeout = function () { timeout.cancel(); };
|
|
|
- timeout.then(cancelPromise);
|
|
|
- promise.then(cancelTimeout, cancelTimeout);
|
|
|
- return promise;
|
|
|
- }
|
|
|
-
|
|
|
- var staticCanceledPromise;
|
|
|
-
|
|
|
- var Promise = _Base.Class.derive(PromiseStateMachine,
|
|
|
- function Promise_ctor(init, oncancel) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise">
|
|
|
- /// <summary locid="WinJS.Promise">
|
|
|
- /// A promise provides a mechanism to schedule work to be done on a value that
|
|
|
- /// has not yet been computed. It is a convenient abstraction for managing
|
|
|
- /// interactions with asynchronous APIs.
|
|
|
- /// </summary>
|
|
|
- /// <param name="init" type="Function" locid="WinJS.Promise_p:init">
|
|
|
- /// The function that is called during construction of the promise. The function
|
|
|
- /// is given three arguments (complete, error, progress). Inside this function
|
|
|
- /// you should add event listeners for the notifications supported by this value.
|
|
|
- /// </param>
|
|
|
- /// <param name="oncancel" optional="true" locid="WinJS.Promise_p:oncancel">
|
|
|
- /// The function to call if a consumer of this promise wants
|
|
|
- /// to cancel its undone work. Promises are not required to
|
|
|
- /// support cancellation.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
-
|
|
|
- if (tagWithStack && (tagWithStack === true || (tagWithStack & tag.promise))) {
|
|
|
- this._stack = Promise._getStack();
|
|
|
- }
|
|
|
-
|
|
|
- this._oncancel = oncancel;
|
|
|
- this._setState(state_created);
|
|
|
- this._run();
|
|
|
-
|
|
|
- try {
|
|
|
- var complete = this._completed.bind(this);
|
|
|
- var error = this._error.bind(this);
|
|
|
- var progress = this._progress.bind(this);
|
|
|
- init(complete, error, progress);
|
|
|
- } catch (ex) {
|
|
|
- this._setExceptionValue(ex);
|
|
|
- }
|
|
|
- }, {
|
|
|
- _oncancel: null,
|
|
|
-
|
|
|
- _cancelAction: function () {
|
|
|
- // BEGIN monaco change
|
|
|
- try {
|
|
|
- if (this._oncancel) {
|
|
|
- this._oncancel();
|
|
|
- } else {
|
|
|
- throw new Error('Promise did not implement oncancel');
|
|
|
- }
|
|
|
- } catch (ex) {
|
|
|
- // Access fields to get them created
|
|
|
- var msg = ex.message;
|
|
|
- var stack = ex.stack;
|
|
|
- promiseEventListeners.dispatchEvent('error', ex);
|
|
|
- }
|
|
|
- // END monaco change
|
|
|
- },
|
|
|
- _cleanupAction: function () { this._oncancel = null; }
|
|
|
- }, {
|
|
|
-
|
|
|
- addEventListener: function Promise_addEventListener(eventType, listener, capture) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.addEventListener">
|
|
|
- /// <summary locid="WinJS.Promise.addEventListener">
|
|
|
- /// Adds an event listener to the control.
|
|
|
- /// </summary>
|
|
|
- /// <param name="eventType" locid="WinJS.Promise.addEventListener_p:eventType">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name="listener" locid="WinJS.Promise.addEventListener_p:listener">
|
|
|
- /// The listener to invoke when the event is raised.
|
|
|
- /// </param>
|
|
|
- /// <param name="capture" locid="WinJS.Promise.addEventListener_p:capture">
|
|
|
- /// Specifies whether or not to initiate capture.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- promiseEventListeners.addEventListener(eventType, listener, capture);
|
|
|
- },
|
|
|
- any: function Promise_any(values) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.any">
|
|
|
- /// <summary locid="WinJS.Promise.any">
|
|
|
- /// Returns a promise that is fulfilled when one of the input promises
|
|
|
- /// has been fulfilled.
|
|
|
- /// </summary>
|
|
|
- /// <param name="values" type="Array" locid="WinJS.Promise.any_p:values">
|
|
|
- /// An array that contains promise objects or objects whose property
|
|
|
- /// values include promise objects.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.any_returnValue">
|
|
|
- /// A promise that on fulfillment yields the value of the input (complete or error).
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return new Promise(
|
|
|
- function (complete, error) {
|
|
|
- var keys = Object.keys(values);
|
|
|
- if (keys.length === 0) {
|
|
|
- complete();
|
|
|
- }
|
|
|
- var canceled = 0;
|
|
|
- keys.forEach(function (key) {
|
|
|
- Promise.as(values[key]).then(
|
|
|
- function () { complete({ key: key, value: values[key] }); },
|
|
|
- function (e) {
|
|
|
- if (e instanceof Error && e.name === canceledName) {
|
|
|
- if ((++canceled) === keys.length) {
|
|
|
- complete(Promise.cancel);
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- error({ key: key, value: values[key] });
|
|
|
- }
|
|
|
- );
|
|
|
- });
|
|
|
- },
|
|
|
- function () {
|
|
|
- var keys = Object.keys(values);
|
|
|
- keys.forEach(function (key) {
|
|
|
- var promise = Promise.as(values[key]);
|
|
|
- if (typeof promise.cancel === "function") {
|
|
|
- promise.cancel();
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- );
|
|
|
- },
|
|
|
- as: function Promise_as(value) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.as">
|
|
|
- /// <summary locid="WinJS.Promise.as">
|
|
|
- /// Returns a promise. If the object is already a promise it is returned;
|
|
|
- /// otherwise the object is wrapped in a promise.
|
|
|
- /// </summary>
|
|
|
- /// <param name="value" locid="WinJS.Promise.as_p:value">
|
|
|
- /// The value to be treated as a promise.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.as_returnValue">
|
|
|
- /// A promise.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- if (value && typeof value === "object" && typeof value.then === "function") {
|
|
|
- return value;
|
|
|
- }
|
|
|
- return new CompletePromise(value);
|
|
|
- },
|
|
|
- /// <field type="WinJS.Promise" helpKeyword="WinJS.Promise.cancel" locid="WinJS.Promise.cancel">
|
|
|
- /// Canceled promise value, can be returned from a promise completion handler
|
|
|
- /// to indicate cancelation of the promise chain.
|
|
|
- /// </field>
|
|
|
- cancel: {
|
|
|
- get: function () {
|
|
|
- return (staticCanceledPromise = staticCanceledPromise || new ErrorPromise(new _ErrorFromName(canceledName)));
|
|
|
- }
|
|
|
- },
|
|
|
- dispatchEvent: function Promise_dispatchEvent(eventType, details) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.dispatchEvent">
|
|
|
- /// <summary locid="WinJS.Promise.dispatchEvent">
|
|
|
- /// Raises an event of the specified type and properties.
|
|
|
- /// </summary>
|
|
|
- /// <param name="eventType" locid="WinJS.Promise.dispatchEvent_p:eventType">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name="details" locid="WinJS.Promise.dispatchEvent_p:details">
|
|
|
- /// The set of additional properties to be attached to the event object.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Boolean" locid="WinJS.Promise.dispatchEvent_returnValue">
|
|
|
- /// Specifies whether preventDefault was called on the event.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return promiseEventListeners.dispatchEvent(eventType, details);
|
|
|
- },
|
|
|
- is: function Promise_is(value) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.is">
|
|
|
- /// <summary locid="WinJS.Promise.is">
|
|
|
- /// Determines whether a value fulfills the promise contract.
|
|
|
- /// </summary>
|
|
|
- /// <param name="value" locid="WinJS.Promise.is_p:value">
|
|
|
- /// A value that may be a promise.
|
|
|
- /// </param>
|
|
|
- /// <returns type="Boolean" locid="WinJS.Promise.is_returnValue">
|
|
|
- /// true if the specified value is a promise, otherwise false.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return value && typeof value === "object" && typeof value.then === "function";
|
|
|
- },
|
|
|
- join: function Promise_join(values) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.join">
|
|
|
- /// <summary locid="WinJS.Promise.join">
|
|
|
- /// Creates a promise that is fulfilled when all the values are fulfilled.
|
|
|
- /// </summary>
|
|
|
- /// <param name="values" type="Object" locid="WinJS.Promise.join_p:values">
|
|
|
- /// An object whose fields contain values, some of which may be promises.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.join_returnValue">
|
|
|
- /// A promise whose value is an object with the same field names as those of the object in the values parameter, where
|
|
|
- /// each field value is the fulfilled value of a promise.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return new Promise(
|
|
|
- function (complete, error, progress) {
|
|
|
- var keys = Object.keys(values);
|
|
|
- var errors = Array.isArray(values) ? [] : {};
|
|
|
- var results = Array.isArray(values) ? [] : {};
|
|
|
- var undefineds = 0;
|
|
|
- var pending = keys.length;
|
|
|
- var argDone = function (key) {
|
|
|
- if ((--pending) === 0) {
|
|
|
- var errorCount = Object.keys(errors).length;
|
|
|
- if (errorCount === 0) {
|
|
|
- complete(results);
|
|
|
- } else {
|
|
|
- var canceledCount = 0;
|
|
|
- keys.forEach(function (key) {
|
|
|
- var e = errors[key];
|
|
|
- if (e instanceof Error && e.name === canceledName) {
|
|
|
- canceledCount++;
|
|
|
- }
|
|
|
- });
|
|
|
- if (canceledCount === errorCount) {
|
|
|
- complete(Promise.cancel);
|
|
|
- } else {
|
|
|
- error(errors);
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- progress({ Key: key, Done: true });
|
|
|
- }
|
|
|
- };
|
|
|
- keys.forEach(function (key) {
|
|
|
- var value = values[key];
|
|
|
- if (value === undefined) {
|
|
|
- undefineds++;
|
|
|
- } else {
|
|
|
- Promise.then(value,
|
|
|
- function (value) { results[key] = value; argDone(key); },
|
|
|
- function (value) { errors[key] = value; argDone(key); }
|
|
|
- );
|
|
|
- }
|
|
|
- });
|
|
|
- pending -= undefineds;
|
|
|
- if (pending === 0) {
|
|
|
- complete(results);
|
|
|
- return;
|
|
|
- }
|
|
|
- },
|
|
|
- function () {
|
|
|
- Object.keys(values).forEach(function (key) {
|
|
|
- var promise = Promise.as(values[key]);
|
|
|
- if (typeof promise.cancel === "function") {
|
|
|
- promise.cancel();
|
|
|
- }
|
|
|
- });
|
|
|
- }
|
|
|
- );
|
|
|
- },
|
|
|
- removeEventListener: function Promise_removeEventListener(eventType, listener, capture) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.removeEventListener">
|
|
|
- /// <summary locid="WinJS.Promise.removeEventListener">
|
|
|
- /// Removes an event listener from the control.
|
|
|
- /// </summary>
|
|
|
- /// <param name='eventType' locid="WinJS.Promise.removeEventListener_eventType">
|
|
|
- /// The type (name) of the event.
|
|
|
- /// </param>
|
|
|
- /// <param name='listener' locid="WinJS.Promise.removeEventListener_listener">
|
|
|
- /// The listener to remove.
|
|
|
- /// </param>
|
|
|
- /// <param name='capture' locid="WinJS.Promise.removeEventListener_capture">
|
|
|
- /// Specifies whether or not to initiate capture.
|
|
|
- /// </param>
|
|
|
- /// </signature>
|
|
|
- promiseEventListeners.removeEventListener(eventType, listener, capture);
|
|
|
- },
|
|
|
- supportedForProcessing: false,
|
|
|
- then: function Promise_then(value, onComplete, onError, onProgress) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.then">
|
|
|
- /// <summary locid="WinJS.Promise.then">
|
|
|
- /// A static version of the promise instance method then().
|
|
|
- /// </summary>
|
|
|
- /// <param name="value" locid="WinJS.Promise.then_p:value">
|
|
|
- /// the value to be treated as a promise.
|
|
|
- /// </param>
|
|
|
- /// <param name="onComplete" type="Function" locid="WinJS.Promise.then_p:complete">
|
|
|
- /// The function to be called if the promise is fulfilled with a value.
|
|
|
- /// If it is null, the promise simply
|
|
|
- /// returns the value. The value is passed as the single argument.
|
|
|
- /// </param>
|
|
|
- /// <param name="onError" type="Function" optional="true" locid="WinJS.Promise.then_p:error">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument.
|
|
|
- /// </param>
|
|
|
- /// <param name="onProgress" type="Function" optional="true" locid="WinJS.Promise.then_p:progress">
|
|
|
- /// The function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.then_returnValue">
|
|
|
- /// A promise whose value is the result of executing the provided complete function.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return Promise.as(value).then(onComplete, onError, onProgress);
|
|
|
- },
|
|
|
- thenEach: function Promise_thenEach(values, onComplete, onError, onProgress) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.thenEach">
|
|
|
- /// <summary locid="WinJS.Promise.thenEach">
|
|
|
- /// Performs an operation on all the input promises and returns a promise
|
|
|
- /// that has the shape of the input and contains the result of the operation
|
|
|
- /// that has been performed on each input.
|
|
|
- /// </summary>
|
|
|
- /// <param name="values" locid="WinJS.Promise.thenEach_p:values">
|
|
|
- /// A set of values (which could be either an array or an object) of which some or all are promises.
|
|
|
- /// </param>
|
|
|
- /// <param name="onComplete" type="Function" locid="WinJS.Promise.thenEach_p:complete">
|
|
|
- /// The function to be called if the promise is fulfilled with a value.
|
|
|
- /// If the value is null, the promise returns the value.
|
|
|
- /// The value is passed as the single argument.
|
|
|
- /// </param>
|
|
|
- /// <param name="onError" type="Function" optional="true" locid="WinJS.Promise.thenEach_p:error">
|
|
|
- /// The function to be called if the promise is fulfilled with an error. The error
|
|
|
- /// is passed as the single argument.
|
|
|
- /// </param>
|
|
|
- /// <param name="onProgress" type="Function" optional="true" locid="WinJS.Promise.thenEach_p:progress">
|
|
|
- /// The function to be called if the promise reports progress. Data about the progress
|
|
|
- /// is passed as the single argument. Promises are not required to support
|
|
|
- /// progress.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.thenEach_returnValue">
|
|
|
- /// A promise that is the result of calling Promise.join on the values parameter.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- var result = Array.isArray(values) ? [] : {};
|
|
|
- Object.keys(values).forEach(function (key) {
|
|
|
- result[key] = Promise.as(values[key]).then(onComplete, onError, onProgress);
|
|
|
- });
|
|
|
- return Promise.join(result);
|
|
|
- },
|
|
|
- timeout: function Promise_timeout(time, promise) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.timeout">
|
|
|
- /// <summary locid="WinJS.Promise.timeout">
|
|
|
- /// Creates a promise that is fulfilled after a timeout.
|
|
|
- /// </summary>
|
|
|
- /// <param name="timeout" type="Number" optional="true" locid="WinJS.Promise.timeout_p:timeout">
|
|
|
- /// The timeout period in milliseconds. If this value is zero or not specified
|
|
|
- /// setImmediate is called, otherwise setTimeout is called.
|
|
|
- /// </param>
|
|
|
- /// <param name="promise" type="Promise" optional="true" locid="WinJS.Promise.timeout_p:promise">
|
|
|
- /// A promise that will be canceled if it doesn't complete before the
|
|
|
- /// timeout has expired.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.timeout_returnValue">
|
|
|
- /// A promise that is completed asynchronously after the specified timeout.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- var to = timeout(time);
|
|
|
- return promise ? timeoutWithPromise(to, promise) : to;
|
|
|
- },
|
|
|
- wrap: function Promise_wrap(value) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.wrap">
|
|
|
- /// <summary locid="WinJS.Promise.wrap">
|
|
|
- /// Wraps a non-promise value in a promise. You can use this function if you need
|
|
|
- /// to pass a value to a function that requires a promise.
|
|
|
- /// </summary>
|
|
|
- /// <param name="value" locid="WinJS.Promise.wrap_p:value">
|
|
|
- /// Some non-promise value to be wrapped in a promise.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.wrap_returnValue">
|
|
|
- /// A promise that is successfully fulfilled with the specified value
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return new CompletePromise(value);
|
|
|
- },
|
|
|
- wrapError: function Promise_wrapError(error) {
|
|
|
- /// <signature helpKeyword="WinJS.Promise.wrapError">
|
|
|
- /// <summary locid="WinJS.Promise.wrapError">
|
|
|
- /// Wraps a non-promise error value in a promise. You can use this function if you need
|
|
|
- /// to pass an error to a function that requires a promise.
|
|
|
- /// </summary>
|
|
|
- /// <param name="error" locid="WinJS.Promise.wrapError_p:error">
|
|
|
- /// A non-promise error value to be wrapped in a promise.
|
|
|
- /// </param>
|
|
|
- /// <returns type="WinJS.Promise" locid="WinJS.Promise.wrapError_returnValue">
|
|
|
- /// A promise that is in an error state with the specified value.
|
|
|
- /// </returns>
|
|
|
- /// </signature>
|
|
|
- return new ErrorPromise(error);
|
|
|
- },
|
|
|
-
|
|
|
- _veryExpensiveTagWithStack: {
|
|
|
- get: function () { return tagWithStack; },
|
|
|
- set: function (value) { tagWithStack = value; }
|
|
|
- },
|
|
|
- _veryExpensiveTagWithStack_tag: tag,
|
|
|
- _getStack: function () {
|
|
|
- if (_Global.Debug && _Global.Debug.debuggerEnabled) {
|
|
|
- try { throw new Error(); } catch (e) { return e.stack; }
|
|
|
- }
|
|
|
- },
|
|
|
-
|
|
|
- _cancelBlocker: function Promise__cancelBlocker(input, oncancel) {
|
|
|
- //
|
|
|
- // Returns a promise which on cancelation will still result in downstream cancelation while
|
|
|
- // protecting the promise 'input' from being canceled which has the effect of allowing
|
|
|
- // 'input' to be shared amoung various consumers.
|
|
|
- //
|
|
|
- if (!Promise.is(input)) {
|
|
|
- return Promise.wrap(input);
|
|
|
- }
|
|
|
- var complete;
|
|
|
- var error;
|
|
|
- var output = new Promise(
|
|
|
- function (c, e) {
|
|
|
- complete = c;
|
|
|
- error = e;
|
|
|
- },
|
|
|
- function () {
|
|
|
- complete = null;
|
|
|
- error = null;
|
|
|
- oncancel && oncancel();
|
|
|
- }
|
|
|
- );
|
|
|
- input.then(
|
|
|
- function (v) { complete && complete(v); },
|
|
|
- function (e) { error && error(e); }
|
|
|
- );
|
|
|
- return output;
|
|
|
- },
|
|
|
-
|
|
|
- }
|
|
|
- );
|
|
|
- Object.defineProperties(Promise, _Events.createEventProperties(errorET));
|
|
|
-
|
|
|
- Promise._doneHandler = function (value) {
|
|
|
- _BaseCoreUtils._setImmediate(function Promise_done_rethrow() {
|
|
|
- throw value;
|
|
|
- });
|
|
|
- };
|
|
|
-
|
|
|
- return {
|
|
|
- PromiseStateMachine: PromiseStateMachine,
|
|
|
- Promise: Promise,
|
|
|
- state_created: state_created
|
|
|
- };
|
|
|
-});
|
|
|
-
|
|
|
-_winjs("WinJS/Promise", ["WinJS/Core/_Base","WinJS/Promise/_StateMachine"], function promiseInit( _Base, _StateMachine) {
|
|
|
- "use strict";
|
|
|
-
|
|
|
- _Base.Namespace.define("WinJS", {
|
|
|
- Promise: _StateMachine.Promise
|
|
|
- });
|
|
|
-
|
|
|
- return _StateMachine.Promise;
|
|
|
-});
|
|
|
-
|
|
|
-var exported = _modules["WinJS/Core/_WinJS"];
|
|
|
-
|
|
|
-if (typeof exports === 'undefined' && typeof define === 'function' && define.amd) {
|
|
|
- define("vs/base/common/winjs.base.raw", exported);
|
|
|
-} else {
|
|
|
- module.exports = exported;
|
|
|
-}
|
|
|
-
|
|
|
-if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {
|
|
|
- _modules["WinJS/Core/_BaseCoreUtils"]._setImmediate = function(handler) {
|
|
|
- return process.nextTick(handler);
|
|
|
- };
|
|
|
-}
|
|
|
-
|
|
|
-})();
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * 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/winjs.base*/], __M([32/*vs/base/common/winjs.base.raw*/]), function (winjs) {
|
|
|
- 'use strict';
|
|
|
- return {
|
|
|
- Promise: winjs.Promise,
|
|
|
- TPromise: winjs.Promise,
|
|
|
- PPromise: winjs.Promise
|
|
|
- };
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[8/*vs/base/common/errors*/], __M([1/*require*/,0/*exports*/,4/*vs/base/common/platform*/,14/*vs/base/common/types*/,2/*vs/base/common/winjs.base*/]), function (require, exports, platform, types, winjs_base_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- // ------ BEGIN Hook up error listeners to winjs promises
|
|
|
- var outstandingPromiseErrors = {};
|
|
|
- function promiseErrorHandler(e) {
|
|
|
- //
|
|
|
- // e.detail looks like: { exception, error, promise, handler, id, parent }
|
|
|
- //
|
|
|
- var details = e.detail;
|
|
|
- var id = details.id;
|
|
|
- // If the error has a parent promise then this is not the origination of the
|
|
|
- // error so we check if it has a handler, and if so we mark that the error
|
|
|
- // was handled by removing it from outstandingPromiseErrors
|
|
|
- //
|
|
|
- if (details.parent) {
|
|
|
- if (details.handler && outstandingPromiseErrors) {
|
|
|
- delete outstandingPromiseErrors[id];
|
|
|
- }
|
|
|
- return;
|
|
|
- }
|
|
|
- // Indicate that this error was originated and needs to be handled
|
|
|
- outstandingPromiseErrors[id] = details;
|
|
|
- // The first time the queue fills up this iteration, schedule a timeout to
|
|
|
- // check if any errors are still unhandled.
|
|
|
- if (Object.keys(outstandingPromiseErrors).length === 1) {
|
|
|
- setTimeout(function () {
|
|
|
- var errors = outstandingPromiseErrors;
|
|
|
- outstandingPromiseErrors = {};
|
|
|
- Object.keys(errors).forEach(function (errorId) {
|
|
|
- var error = errors[errorId];
|
|
|
- if (error.exception) {
|
|
|
- onUnexpectedError(error.exception);
|
|
|
- }
|
|
|
- else if (error.error) {
|
|
|
- onUnexpectedError(error.error);
|
|
|
- }
|
|
|
- console.log('WARNING: Promise with no error callback:' + error.id);
|
|
|
- console.log(error);
|
|
|
- if (error.exception) {
|
|
|
- console.log(error.exception.stack);
|
|
|
- }
|
|
|
- });
|
|
|
- }, 0);
|
|
|
- }
|
|
|
- }
|
|
|
- winjs_base_1.TPromise.addEventListener('error', promiseErrorHandler);
|
|
|
- // Avoid circular dependency on EventEmitter by implementing a subset of the interface.
|
|
|
- var ErrorHandler = (function () {
|
|
|
- function ErrorHandler() {
|
|
|
- this.listeners = [];
|
|
|
- this.unexpectedErrorHandler = function (e) {
|
|
|
- platform.setTimeout(function () {
|
|
|
- if (e.stack) {
|
|
|
- throw new Error(e.message + '\n\n' + e.stack);
|
|
|
- }
|
|
|
- throw e;
|
|
|
- }, 0);
|
|
|
- };
|
|
|
- }
|
|
|
- ErrorHandler.prototype.addListener = function (listener) {
|
|
|
- var _this = this;
|
|
|
- this.listeners.push(listener);
|
|
|
- return function () {
|
|
|
- _this._removeListener(listener);
|
|
|
- };
|
|
|
- };
|
|
|
- ErrorHandler.prototype.emit = function (e) {
|
|
|
- this.listeners.forEach(function (listener) {
|
|
|
- listener(e);
|
|
|
- });
|
|
|
- };
|
|
|
- ErrorHandler.prototype._removeListener = function (listener) {
|
|
|
- this.listeners.splice(this.listeners.indexOf(listener), 1);
|
|
|
- };
|
|
|
- ErrorHandler.prototype.setUnexpectedErrorHandler = function (newUnexpectedErrorHandler) {
|
|
|
- this.unexpectedErrorHandler = newUnexpectedErrorHandler;
|
|
|
- };
|
|
|
- ErrorHandler.prototype.getUnexpectedErrorHandler = function () {
|
|
|
- return this.unexpectedErrorHandler;
|
|
|
- };
|
|
|
- ErrorHandler.prototype.onUnexpectedError = function (e) {
|
|
|
- this.unexpectedErrorHandler(e);
|
|
|
- this.emit(e);
|
|
|
- };
|
|
|
- // For external errors, we don't want the listeners to be called
|
|
|
- ErrorHandler.prototype.onUnexpectedExternalError = function (e) {
|
|
|
- this.unexpectedErrorHandler(e);
|
|
|
- };
|
|
|
- return ErrorHandler;
|
|
|
- }());
|
|
|
- exports.ErrorHandler = ErrorHandler;
|
|
|
- exports.errorHandler = new ErrorHandler();
|
|
|
- function setUnexpectedErrorHandler(newUnexpectedErrorHandler) {
|
|
|
- exports.errorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler);
|
|
|
- }
|
|
|
- exports.setUnexpectedErrorHandler = setUnexpectedErrorHandler;
|
|
|
- function onUnexpectedError(e) {
|
|
|
- // ignore errors from cancelled promises
|
|
|
- if (!isPromiseCanceledError(e)) {
|
|
|
- exports.errorHandler.onUnexpectedError(e);
|
|
|
- }
|
|
|
- }
|
|
|
- exports.onUnexpectedError = onUnexpectedError;
|
|
|
- function onUnexpectedExternalError(e) {
|
|
|
- // ignore errors from cancelled promises
|
|
|
- if (!isPromiseCanceledError(e)) {
|
|
|
- exports.errorHandler.onUnexpectedExternalError(e);
|
|
|
- }
|
|
|
- }
|
|
|
- exports.onUnexpectedExternalError = onUnexpectedExternalError;
|
|
|
- function onUnexpectedPromiseError(promise) {
|
|
|
- return promise.then(null, onUnexpectedError);
|
|
|
- }
|
|
|
- exports.onUnexpectedPromiseError = onUnexpectedPromiseError;
|
|
|
- function transformErrorForSerialization(error) {
|
|
|
- if (error instanceof Error) {
|
|
|
- var name_1 = error.name, message = error.message;
|
|
|
- var stack = error.stacktrace || error.stack;
|
|
|
- return {
|
|
|
- $isError: true,
|
|
|
- name: name_1,
|
|
|
- message: message,
|
|
|
- stack: stack
|
|
|
- };
|
|
|
- }
|
|
|
- // return as is
|
|
|
- return error;
|
|
|
- }
|
|
|
- exports.transformErrorForSerialization = transformErrorForSerialization;
|
|
|
- var canceledName = 'Canceled';
|
|
|
- /**
|
|
|
- * Checks if the given error is a promise in canceled state
|
|
|
- */
|
|
|
- function isPromiseCanceledError(error) {
|
|
|
- return error instanceof Error && error.name === canceledName && error.message === canceledName;
|
|
|
- }
|
|
|
- exports.isPromiseCanceledError = isPromiseCanceledError;
|
|
|
- /**
|
|
|
- * Returns an error that signals cancellation.
|
|
|
- */
|
|
|
- function canceled() {
|
|
|
- var error = new Error(canceledName);
|
|
|
- error.name = error.message;
|
|
|
- return error;
|
|
|
- }
|
|
|
- exports.canceled = canceled;
|
|
|
- /**
|
|
|
- * Returns an error that signals something is not implemented.
|
|
|
- */
|
|
|
- function notImplemented() {
|
|
|
- return new Error('Not Implemented');
|
|
|
- }
|
|
|
- exports.notImplemented = notImplemented;
|
|
|
- function illegalArgument(name) {
|
|
|
- if (name) {
|
|
|
- return new Error("Illegal argument: " + name);
|
|
|
- }
|
|
|
- else {
|
|
|
- return new Error('Illegal argument');
|
|
|
- }
|
|
|
- }
|
|
|
- exports.illegalArgument = illegalArgument;
|
|
|
- function illegalState(name) {
|
|
|
- if (name) {
|
|
|
- return new Error("Illegal state: " + name);
|
|
|
- }
|
|
|
- else {
|
|
|
- return new Error('Illegal state');
|
|
|
- }
|
|
|
- }
|
|
|
- exports.illegalState = illegalState;
|
|
|
- function readonly(name) {
|
|
|
- return name
|
|
|
- ? new Error("readonly property '" + name + " cannot be changed'")
|
|
|
- : new Error('readonly property cannot be changed');
|
|
|
- }
|
|
|
- exports.readonly = readonly;
|
|
|
- function create(message, options) {
|
|
|
- if (options === void 0) { options = {}; }
|
|
|
- var result = new Error(message);
|
|
|
- if (types.isNumber(options.severity)) {
|
|
|
- result.severity = options.severity;
|
|
|
- }
|
|
|
- if (options.actions) {
|
|
|
- result.actions = options.actions;
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.create = create;
|
|
|
- function getErrorMessage(err) {
|
|
|
- if (!err) {
|
|
|
- return 'Error';
|
|
|
- }
|
|
|
- if (err.message) {
|
|
|
- return err.message;
|
|
|
- }
|
|
|
- if (err.stack) {
|
|
|
- return err.stack.split('\n')[0];
|
|
|
- }
|
|
|
- return String(err);
|
|
|
- }
|
|
|
- exports.getErrorMessage = getErrorMessage;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[15/*vs/base/common/callbackList*/], __M([1/*require*/,0/*exports*/,8/*vs/base/common/errors*/]), function (require, exports, errors_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var CallbackList = (function () {
|
|
|
- function CallbackList() {
|
|
|
- }
|
|
|
- CallbackList.prototype.add = function (callback, context, bucket) {
|
|
|
- var _this = this;
|
|
|
- if (context === void 0) { context = null; }
|
|
|
- if (!this._callbacks) {
|
|
|
- this._callbacks = [];
|
|
|
- this._contexts = [];
|
|
|
- }
|
|
|
- this._callbacks.push(callback);
|
|
|
- this._contexts.push(context);
|
|
|
- if (Array.isArray(bucket)) {
|
|
|
- bucket.push({ dispose: function () { return _this.remove(callback, context); } });
|
|
|
- }
|
|
|
- };
|
|
|
- CallbackList.prototype.remove = function (callback, context) {
|
|
|
- if (context === void 0) { context = null; }
|
|
|
- if (!this._callbacks) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var foundCallbackWithDifferentContext = false;
|
|
|
- for (var i = 0, len = this._callbacks.length; i < len; i++) {
|
|
|
- if (this._callbacks[i] === callback) {
|
|
|
- if (this._contexts[i] === context) {
|
|
|
- // callback & context match => remove it
|
|
|
- this._callbacks.splice(i, 1);
|
|
|
- this._contexts.splice(i, 1);
|
|
|
- return;
|
|
|
- }
|
|
|
- else {
|
|
|
- foundCallbackWithDifferentContext = true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (foundCallbackWithDifferentContext) {
|
|
|
- throw new Error('When adding a listener with a context, you should remove it with the same context');
|
|
|
- }
|
|
|
- };
|
|
|
- CallbackList.prototype.invoke = function () {
|
|
|
- var args = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- args[_i] = arguments[_i];
|
|
|
- }
|
|
|
- if (!this._callbacks) {
|
|
|
- return undefined;
|
|
|
- }
|
|
|
- var ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
|
|
|
- for (var i = 0, len = callbacks.length; i < len; i++) {
|
|
|
- try {
|
|
|
- ret.push(callbacks[i].apply(contexts[i], args));
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- errors_1.onUnexpectedError(e);
|
|
|
- }
|
|
|
- }
|
|
|
- return ret;
|
|
|
- };
|
|
|
- CallbackList.prototype.isEmpty = function () {
|
|
|
- return !this._callbacks || this._callbacks.length === 0;
|
|
|
- };
|
|
|
- CallbackList.prototype.entries = function () {
|
|
|
- var _this = this;
|
|
|
- if (!this._callbacks) {
|
|
|
- return [];
|
|
|
- }
|
|
|
- return this._callbacks.map(function (fn, index) { return [fn, _this._contexts[index]]; });
|
|
|
- };
|
|
|
- CallbackList.prototype.dispose = function () {
|
|
|
- this._callbacks = undefined;
|
|
|
- this._contexts = undefined;
|
|
|
- };
|
|
|
- return CallbackList;
|
|
|
- }());
|
|
|
- exports.default = CallbackList;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[9/*vs/base/common/event*/], __M([1/*require*/,0/*exports*/,10/*vs/base/common/lifecycle*/,15/*vs/base/common/callbackList*/,2/*vs/base/common/winjs.base*/,11/*vs/base/common/functional*/]), function (require, exports, lifecycle_1, callbackList_1, winjs_base_1, functional_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var Event;
|
|
|
- (function (Event) {
|
|
|
- var _disposable = { dispose: function () { } };
|
|
|
- Event.None = function () { return _disposable; };
|
|
|
- })(Event || (Event = {}));
|
|
|
- exports.default = Event;
|
|
|
- /**
|
|
|
- * The Emitter can be used to expose an Event to the public
|
|
|
- * to fire it from the insides.
|
|
|
- * Sample:
|
|
|
- class Document {
|
|
|
-
|
|
|
- private _onDidChange = new Emitter<(value:string)=>any>();
|
|
|
-
|
|
|
- public onDidChange = this._onDidChange.event;
|
|
|
-
|
|
|
- // getter-style
|
|
|
- // get onDidChange(): Event<(value:string)=>any> {
|
|
|
- // return this._onDidChange.event;
|
|
|
- // }
|
|
|
-
|
|
|
- private _doIt() {
|
|
|
- //...
|
|
|
- this._onDidChange.fire(value);
|
|
|
- }
|
|
|
- }
|
|
|
- */
|
|
|
- var Emitter = (function () {
|
|
|
- function Emitter(_options) {
|
|
|
- this._options = _options;
|
|
|
- }
|
|
|
- Object.defineProperty(Emitter.prototype, "event", {
|
|
|
- /**
|
|
|
- * For the public to allow to subscribe
|
|
|
- * to events from this Emitter
|
|
|
- */
|
|
|
- get: function () {
|
|
|
- var _this = this;
|
|
|
- if (!this._event) {
|
|
|
- this._event = function (listener, thisArgs, disposables) {
|
|
|
- if (!_this._callbacks) {
|
|
|
- _this._callbacks = new callbackList_1.default();
|
|
|
- }
|
|
|
- var firstListener = _this._callbacks.isEmpty();
|
|
|
- if (firstListener && _this._options && _this._options.onFirstListenerAdd) {
|
|
|
- _this._options.onFirstListenerAdd(_this);
|
|
|
- }
|
|
|
- _this._callbacks.add(listener, thisArgs);
|
|
|
- if (firstListener && _this._options && _this._options.onFirstListenerDidAdd) {
|
|
|
- _this._options.onFirstListenerDidAdd(_this);
|
|
|
- }
|
|
|
- if (_this._options && _this._options.onListenerDidAdd) {
|
|
|
- _this._options.onListenerDidAdd(_this, listener, thisArgs);
|
|
|
- }
|
|
|
- var result;
|
|
|
- result = {
|
|
|
- dispose: function () {
|
|
|
- result.dispose = Emitter._noop;
|
|
|
- if (!_this._disposed) {
|
|
|
- _this._callbacks.remove(listener, thisArgs);
|
|
|
- if (_this._options && _this._options.onLastListenerRemove && _this._callbacks.isEmpty()) {
|
|
|
- _this._options.onLastListenerRemove(_this);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- if (Array.isArray(disposables)) {
|
|
|
- disposables.push(result);
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- }
|
|
|
- return this._event;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- /**
|
|
|
- * To be kept private to fire an event to
|
|
|
- * subscribers
|
|
|
- */
|
|
|
- Emitter.prototype.fire = function (event) {
|
|
|
- if (this._callbacks) {
|
|
|
- this._callbacks.invoke.call(this._callbacks, event);
|
|
|
- }
|
|
|
- };
|
|
|
- Emitter.prototype.dispose = function () {
|
|
|
- if (this._callbacks) {
|
|
|
- this._callbacks.dispose();
|
|
|
- this._callbacks = undefined;
|
|
|
- this._disposed = true;
|
|
|
- }
|
|
|
- };
|
|
|
- return Emitter;
|
|
|
- }());
|
|
|
- Emitter._noop = function () { };
|
|
|
- exports.Emitter = Emitter;
|
|
|
- var EventMultiplexer = (function () {
|
|
|
- function EventMultiplexer() {
|
|
|
- var _this = this;
|
|
|
- this.hasListeners = false;
|
|
|
- this.events = [];
|
|
|
- this.emitter = new Emitter({
|
|
|
- onFirstListenerAdd: function () { return _this.onFirstListenerAdd(); },
|
|
|
- onLastListenerRemove: function () { return _this.onLastListenerRemove(); }
|
|
|
- });
|
|
|
- }
|
|
|
- Object.defineProperty(EventMultiplexer.prototype, "event", {
|
|
|
- get: function () {
|
|
|
- return this.emitter.event;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- EventMultiplexer.prototype.add = function (event) {
|
|
|
- var _this = this;
|
|
|
- var e = { event: event, listener: null };
|
|
|
- this.events.push(e);
|
|
|
- if (this.hasListeners) {
|
|
|
- this.hook(e);
|
|
|
- }
|
|
|
- var dispose = function () {
|
|
|
- if (_this.hasListeners) {
|
|
|
- _this.unhook(e);
|
|
|
- }
|
|
|
- var idx = _this.events.indexOf(e);
|
|
|
- _this.events.splice(idx, 1);
|
|
|
- };
|
|
|
- return lifecycle_1.toDisposable(functional_1.once(dispose));
|
|
|
- };
|
|
|
- EventMultiplexer.prototype.onFirstListenerAdd = function () {
|
|
|
- var _this = this;
|
|
|
- this.hasListeners = true;
|
|
|
- this.events.forEach(function (e) { return _this.hook(e); });
|
|
|
- };
|
|
|
- EventMultiplexer.prototype.onLastListenerRemove = function () {
|
|
|
- var _this = this;
|
|
|
- this.hasListeners = false;
|
|
|
- this.events.forEach(function (e) { return _this.unhook(e); });
|
|
|
- };
|
|
|
- EventMultiplexer.prototype.hook = function (e) {
|
|
|
- var _this = this;
|
|
|
- e.listener = e.event(function (r) { return _this.emitter.fire(r); });
|
|
|
- };
|
|
|
- EventMultiplexer.prototype.unhook = function (e) {
|
|
|
- e.listener.dispose();
|
|
|
- e.listener = null;
|
|
|
- };
|
|
|
- EventMultiplexer.prototype.dispose = function () {
|
|
|
- this.emitter.dispose();
|
|
|
- };
|
|
|
- return EventMultiplexer;
|
|
|
- }());
|
|
|
- exports.EventMultiplexer = EventMultiplexer;
|
|
|
- /**
|
|
|
- * Creates an Event which is backed-up by the event emitter. This allows
|
|
|
- * to use the existing eventing pattern and is likely using less memory.
|
|
|
- * Sample:
|
|
|
- *
|
|
|
- * class Document {
|
|
|
- *
|
|
|
- * private _eventbus = new EventEmitter();
|
|
|
- *
|
|
|
- * public onDidChange = fromEventEmitter(this._eventbus, 'changed');
|
|
|
- *
|
|
|
- * // getter-style
|
|
|
- * // get onDidChange(): Event<(value:string)=>any> {
|
|
|
- * // cache fromEventEmitter result and return
|
|
|
- * // }
|
|
|
- *
|
|
|
- * private _doIt() {
|
|
|
- * // ...
|
|
|
- * this._eventbus.emit('changed', value)
|
|
|
- * }
|
|
|
- * }
|
|
|
- */
|
|
|
- function fromEventEmitter(emitter, eventType) {
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- var result = emitter.addListener(eventType, function () {
|
|
|
- listener.apply(thisArgs, arguments);
|
|
|
- });
|
|
|
- if (Array.isArray(disposables)) {
|
|
|
- disposables.push(result);
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- }
|
|
|
- exports.fromEventEmitter = fromEventEmitter;
|
|
|
- function fromCallback(fn) {
|
|
|
- var listener;
|
|
|
- var emitter = new Emitter({
|
|
|
- onFirstListenerAdd: function () { return listener = fn(function (e) { return emitter.fire(e); }); },
|
|
|
- onLastListenerRemove: function () { return listener.dispose(); }
|
|
|
- });
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.fromCallback = fromCallback;
|
|
|
- function fromPromise(promise) {
|
|
|
- var emitter = new Emitter();
|
|
|
- var shouldEmit = false;
|
|
|
- promise
|
|
|
- .then(null, function () { return null; })
|
|
|
- .then(function () {
|
|
|
- if (!shouldEmit) {
|
|
|
- setTimeout(function () { return emitter.fire(); }, 0);
|
|
|
- }
|
|
|
- else {
|
|
|
- emitter.fire();
|
|
|
- }
|
|
|
- });
|
|
|
- shouldEmit = true;
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.fromPromise = fromPromise;
|
|
|
- function toPromise(event) {
|
|
|
- return new winjs_base_1.TPromise(function (complete) {
|
|
|
- var sub = event(function (e) {
|
|
|
- sub.dispose();
|
|
|
- complete(e);
|
|
|
- });
|
|
|
- });
|
|
|
- }
|
|
|
- exports.toPromise = toPromise;
|
|
|
- function delayed(promise) {
|
|
|
- var toCancel = null;
|
|
|
- var listener = null;
|
|
|
- var emitter = new Emitter({
|
|
|
- onFirstListenerAdd: function () {
|
|
|
- toCancel = promise.then(function (event) { return listener = event(function (e) { return emitter.fire(e); }); }, function () { return null; });
|
|
|
- },
|
|
|
- onLastListenerRemove: function () {
|
|
|
- if (toCancel) {
|
|
|
- toCancel.cancel();
|
|
|
- toCancel = null;
|
|
|
- }
|
|
|
- if (listener) {
|
|
|
- listener.dispose();
|
|
|
- listener = null;
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.delayed = delayed;
|
|
|
- function once(event) {
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- if (thisArgs === void 0) { thisArgs = null; }
|
|
|
- var result = event(function (e) {
|
|
|
- result.dispose();
|
|
|
- return listener.call(thisArgs, e);
|
|
|
- }, null, disposables);
|
|
|
- return result;
|
|
|
- };
|
|
|
- }
|
|
|
- exports.once = once;
|
|
|
- function any() {
|
|
|
- var events = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- events[_i] = arguments[_i];
|
|
|
- }
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- if (thisArgs === void 0) { thisArgs = null; }
|
|
|
- return lifecycle_1.combinedDisposable(events.map(function (event) { return event(function (e) { return listener.call(thisArgs, e); }, null, disposables); }));
|
|
|
- };
|
|
|
- }
|
|
|
- exports.any = any;
|
|
|
- function debounceEvent(event, merger, delay, leading) {
|
|
|
- if (delay === void 0) { delay = 100; }
|
|
|
- if (leading === void 0) { leading = false; }
|
|
|
- var subscription;
|
|
|
- var output;
|
|
|
- var handle;
|
|
|
- var emitter = new Emitter({
|
|
|
- onFirstListenerAdd: function () {
|
|
|
- subscription = event(function (cur) {
|
|
|
- output = merger(output, cur);
|
|
|
- if (!handle && leading) {
|
|
|
- emitter.fire(output);
|
|
|
- }
|
|
|
- clearTimeout(handle);
|
|
|
- handle = setTimeout(function () {
|
|
|
- var _output = output;
|
|
|
- output = undefined;
|
|
|
- emitter.fire(_output);
|
|
|
- handle = null;
|
|
|
- }, delay);
|
|
|
- });
|
|
|
- },
|
|
|
- onLastListenerRemove: function () {
|
|
|
- subscription.dispose();
|
|
|
- }
|
|
|
- });
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.debounceEvent = debounceEvent;
|
|
|
- /**
|
|
|
- * The EventDelayer is useful in situations in which you want
|
|
|
- * to delay firing your events during some code.
|
|
|
- * You can wrap that code and be sure that the event will not
|
|
|
- * be fired during that wrap.
|
|
|
- *
|
|
|
- * ```
|
|
|
- * const emitter: Emitter;
|
|
|
- * const delayer = new EventDelayer();
|
|
|
- * const delayedEvent = delayer.wrapEvent(emitter.event);
|
|
|
- *
|
|
|
- * delayedEvent(console.log);
|
|
|
- *
|
|
|
- * delayer.bufferEvents(() => {
|
|
|
- * emitter.fire(); // event will not be fired yet
|
|
|
- * });
|
|
|
- *
|
|
|
- * // event will only be fired at this point
|
|
|
- * ```
|
|
|
- */
|
|
|
- var EventBufferer = (function () {
|
|
|
- function EventBufferer() {
|
|
|
- this.buffers = [];
|
|
|
- }
|
|
|
- EventBufferer.prototype.wrapEvent = function (event) {
|
|
|
- var _this = this;
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- return event(function (i) {
|
|
|
- var buffer = _this.buffers[_this.buffers.length - 1];
|
|
|
- if (buffer) {
|
|
|
- buffer.push(function () { return listener.call(thisArgs, i); });
|
|
|
- }
|
|
|
- else {
|
|
|
- listener.call(thisArgs, i);
|
|
|
- }
|
|
|
- }, void 0, disposables);
|
|
|
- };
|
|
|
- };
|
|
|
- EventBufferer.prototype.bufferEvents = function (fn) {
|
|
|
- var buffer = [];
|
|
|
- this.buffers.push(buffer);
|
|
|
- fn();
|
|
|
- this.buffers.pop();
|
|
|
- buffer.forEach(function (flush) { return flush(); });
|
|
|
- };
|
|
|
- return EventBufferer;
|
|
|
- }());
|
|
|
- exports.EventBufferer = EventBufferer;
|
|
|
- function mapEvent(event, map) {
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- if (thisArgs === void 0) { thisArgs = null; }
|
|
|
- return event(function (i) { return listener.call(thisArgs, map(i)); }, null, disposables);
|
|
|
- };
|
|
|
- }
|
|
|
- exports.mapEvent = mapEvent;
|
|
|
- function filterEvent(event, filter) {
|
|
|
- return function (listener, thisArgs, disposables) {
|
|
|
- if (thisArgs === void 0) { thisArgs = null; }
|
|
|
- return event(function (e) { return filter(e) && listener.call(thisArgs, e); }, null, disposables);
|
|
|
- };
|
|
|
- }
|
|
|
- exports.filterEvent = filterEvent;
|
|
|
- var ChainableEvent = (function () {
|
|
|
- function ChainableEvent(_event) {
|
|
|
- this._event = _event;
|
|
|
- }
|
|
|
- Object.defineProperty(ChainableEvent.prototype, "event", {
|
|
|
- get: function () { return this._event; },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- ChainableEvent.prototype.map = function (fn) {
|
|
|
- return new ChainableEvent(mapEvent(this._event, fn));
|
|
|
- };
|
|
|
- ChainableEvent.prototype.filter = function (fn) {
|
|
|
- return new ChainableEvent(filterEvent(this._event, fn));
|
|
|
- };
|
|
|
- ChainableEvent.prototype.on = function (listener, thisArgs, disposables) {
|
|
|
- return this._event(listener, thisArgs, disposables);
|
|
|
- };
|
|
|
- return ChainableEvent;
|
|
|
- }());
|
|
|
- function chain(event) {
|
|
|
- return new ChainableEvent(event);
|
|
|
- }
|
|
|
- exports.chain = chain;
|
|
|
- function stopwatch(event) {
|
|
|
- var start = new Date().getTime();
|
|
|
- return mapEvent(once(event), function (_) { return new Date().getTime() - start; });
|
|
|
- }
|
|
|
- exports.stopwatch = stopwatch;
|
|
|
- /**
|
|
|
- * Buffers the provided event until a first listener comes
|
|
|
- * along, at which point fire all the events at once and
|
|
|
- * pipe the event from then on.
|
|
|
- *
|
|
|
- * ```typescript
|
|
|
- * const emitter = new Emitter<number>();
|
|
|
- * const event = emitter.event;
|
|
|
- * const bufferedEvent = buffer(event);
|
|
|
- *
|
|
|
- * emitter.fire(1);
|
|
|
- * emitter.fire(2);
|
|
|
- * emitter.fire(3);
|
|
|
- * // nothing...
|
|
|
- *
|
|
|
- * const listener = bufferedEvent(num => console.log(num));
|
|
|
- * // 1, 2, 3
|
|
|
- *
|
|
|
- * emitter.fire(4);
|
|
|
- * // 4
|
|
|
- * ```
|
|
|
- */
|
|
|
- function buffer(event, nextTick, buffer) {
|
|
|
- if (nextTick === void 0) { nextTick = false; }
|
|
|
- if (buffer === void 0) { buffer = []; }
|
|
|
- buffer = buffer.slice();
|
|
|
- var listener = event(function (e) {
|
|
|
- if (buffer) {
|
|
|
- buffer.push(e);
|
|
|
- }
|
|
|
- else {
|
|
|
- emitter.fire(e);
|
|
|
- }
|
|
|
- });
|
|
|
- var flush = function () {
|
|
|
- buffer.forEach(function (e) { return emitter.fire(e); });
|
|
|
- buffer = null;
|
|
|
- };
|
|
|
- var emitter = new Emitter({
|
|
|
- onFirstListenerAdd: function () {
|
|
|
- if (!listener) {
|
|
|
- listener = event(function (e) { return emitter.fire(e); });
|
|
|
- }
|
|
|
- },
|
|
|
- onFirstListenerDidAdd: function () {
|
|
|
- if (buffer) {
|
|
|
- if (nextTick) {
|
|
|
- setTimeout(flush);
|
|
|
- }
|
|
|
- else {
|
|
|
- flush();
|
|
|
- }
|
|
|
- }
|
|
|
- },
|
|
|
- onLastListenerRemove: function () {
|
|
|
- listener.dispose();
|
|
|
- listener = null;
|
|
|
- }
|
|
|
- });
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.buffer = buffer;
|
|
|
- /**
|
|
|
- * Similar to `buffer` but it buffers indefinitely and repeats
|
|
|
- * the buffered events to every new listener.
|
|
|
- */
|
|
|
- function echo(event, nextTick, buffer) {
|
|
|
- if (nextTick === void 0) { nextTick = false; }
|
|
|
- if (buffer === void 0) { buffer = []; }
|
|
|
- buffer = buffer.slice();
|
|
|
- event(function (e) {
|
|
|
- buffer.push(e);
|
|
|
- emitter.fire(e);
|
|
|
- });
|
|
|
- var flush = function (listener, thisArgs) { return buffer.forEach(function (e) { return listener.call(thisArgs, e); }); };
|
|
|
- var emitter = new Emitter({
|
|
|
- onListenerDidAdd: function (emitter, listener, thisArgs) {
|
|
|
- if (nextTick) {
|
|
|
- setTimeout(function () { return flush(listener, thisArgs); });
|
|
|
- }
|
|
|
- else {
|
|
|
- flush(listener, thisArgs);
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- return emitter.event;
|
|
|
- }
|
|
|
- exports.echo = echo;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-define(__m[13/*vs/base/common/cancellation*/], __M([1/*require*/,0/*exports*/,9/*vs/base/common/event*/]), function (require, exports, event_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var shortcutEvent = Object.freeze(function (callback, context) {
|
|
|
- var handle = setTimeout(callback.bind(context), 0);
|
|
|
- return { dispose: function () { clearTimeout(handle); } };
|
|
|
- });
|
|
|
- var CancellationToken;
|
|
|
- (function (CancellationToken) {
|
|
|
- CancellationToken.None = Object.freeze({
|
|
|
- isCancellationRequested: false,
|
|
|
- onCancellationRequested: event_1.default.None
|
|
|
- });
|
|
|
- CancellationToken.Cancelled = Object.freeze({
|
|
|
- isCancellationRequested: true,
|
|
|
- onCancellationRequested: shortcutEvent
|
|
|
- });
|
|
|
- })(CancellationToken = exports.CancellationToken || (exports.CancellationToken = {}));
|
|
|
- var MutableToken = (function () {
|
|
|
- function MutableToken() {
|
|
|
- this._isCancelled = false;
|
|
|
- }
|
|
|
- MutableToken.prototype.cancel = function () {
|
|
|
- if (!this._isCancelled) {
|
|
|
- this._isCancelled = true;
|
|
|
- if (this._emitter) {
|
|
|
- this._emitter.fire(undefined);
|
|
|
- this._emitter = undefined;
|
|
|
- }
|
|
|
- }
|
|
|
- };
|
|
|
- Object.defineProperty(MutableToken.prototype, "isCancellationRequested", {
|
|
|
- get: function () {
|
|
|
- return this._isCancelled;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(MutableToken.prototype, "onCancellationRequested", {
|
|
|
- get: function () {
|
|
|
- if (this._isCancelled) {
|
|
|
- return shortcutEvent;
|
|
|
- }
|
|
|
- if (!this._emitter) {
|
|
|
- this._emitter = new event_1.Emitter();
|
|
|
- }
|
|
|
- return this._emitter.event;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- return MutableToken;
|
|
|
- }());
|
|
|
- var CancellationTokenSource = (function () {
|
|
|
- function CancellationTokenSource() {
|
|
|
- }
|
|
|
- Object.defineProperty(CancellationTokenSource.prototype, "token", {
|
|
|
- get: function () {
|
|
|
- if (!this._token) {
|
|
|
- // be lazy and create the token only when
|
|
|
- // actually needed
|
|
|
- this._token = new MutableToken();
|
|
|
- }
|
|
|
- return this._token;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- CancellationTokenSource.prototype.cancel = function () {
|
|
|
- if (!this._token) {
|
|
|
- // save an object by returning the default
|
|
|
- // cancelled token when cancellation happens
|
|
|
- // before someone asks for the token
|
|
|
- this._token = CancellationToken.Cancelled;
|
|
|
- }
|
|
|
- else {
|
|
|
- this._token.cancel();
|
|
|
- }
|
|
|
- };
|
|
|
- CancellationTokenSource.prototype.dispose = function () {
|
|
|
- this.cancel();
|
|
|
- };
|
|
|
- return CancellationTokenSource;
|
|
|
- }());
|
|
|
- exports.CancellationTokenSource = CancellationTokenSource;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-define(__m[18/*vs/base/common/async*/], __M([1/*require*/,0/*exports*/,8/*vs/base/common/errors*/,4/*vs/base/common/platform*/,2/*vs/base/common/winjs.base*/,13/*vs/base/common/cancellation*/,10/*vs/base/common/lifecycle*/,9/*vs/base/common/event*/]), function (require, exports, errors, platform, winjs_base_1, cancellation_1, lifecycle_1, event_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- function isThenable(obj) {
|
|
|
- return obj && typeof obj.then === 'function';
|
|
|
- }
|
|
|
- function toThenable(arg) {
|
|
|
- if (isThenable(arg)) {
|
|
|
- return arg;
|
|
|
- }
|
|
|
- else {
|
|
|
- return winjs_base_1.TPromise.as(arg);
|
|
|
- }
|
|
|
- }
|
|
|
- exports.toThenable = toThenable;
|
|
|
- function asWinJsPromise(callback) {
|
|
|
- var source = new cancellation_1.CancellationTokenSource();
|
|
|
- return new winjs_base_1.TPromise(function (resolve, reject, progress) {
|
|
|
- var item = callback(source.token);
|
|
|
- if (item instanceof winjs_base_1.TPromise) {
|
|
|
- item.then(resolve, reject, progress);
|
|
|
- }
|
|
|
- else if (isThenable(item)) {
|
|
|
- item.then(resolve, reject);
|
|
|
- }
|
|
|
- else {
|
|
|
- resolve(item);
|
|
|
- }
|
|
|
- }, function () {
|
|
|
- source.cancel();
|
|
|
- });
|
|
|
- }
|
|
|
- exports.asWinJsPromise = asWinJsPromise;
|
|
|
- /**
|
|
|
- * Hook a cancellation token to a WinJS Promise
|
|
|
- */
|
|
|
- function wireCancellationToken(token, promise, resolveAsUndefinedWhenCancelled) {
|
|
|
- var subscription = token.onCancellationRequested(function () { return promise.cancel(); });
|
|
|
- if (resolveAsUndefinedWhenCancelled) {
|
|
|
- promise = promise.then(undefined, function (err) {
|
|
|
- if (!errors.isPromiseCanceledError(err)) {
|
|
|
- return winjs_base_1.TPromise.wrapError(err);
|
|
|
- }
|
|
|
- return undefined;
|
|
|
- });
|
|
|
- }
|
|
|
- return always(promise, function () { return subscription.dispose(); });
|
|
|
- }
|
|
|
- exports.wireCancellationToken = wireCancellationToken;
|
|
|
- /**
|
|
|
- * A helper to prevent accumulation of sequential async tasks.
|
|
|
- *
|
|
|
- * Imagine a mail man with the sole task of delivering letters. As soon as
|
|
|
- * a letter submitted for delivery, he drives to the destination, delivers it
|
|
|
- * and returns to his base. Imagine that during the trip, N more letters were submitted.
|
|
|
- * When the mail man returns, he picks those N letters and delivers them all in a
|
|
|
- * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
|
|
|
- *
|
|
|
- * The throttler implements this via the queue() method, by providing it a task
|
|
|
- * factory. Following the example:
|
|
|
- *
|
|
|
- * const throttler = new Throttler();
|
|
|
- * const letters = [];
|
|
|
- *
|
|
|
- * function deliver() {
|
|
|
- * const lettersToDeliver = letters;
|
|
|
- * letters = [];
|
|
|
- * return makeTheTrip(lettersToDeliver);
|
|
|
- * }
|
|
|
- *
|
|
|
- * function onLetterReceived(l) {
|
|
|
- * letters.push(l);
|
|
|
- * throttler.queue(deliver);
|
|
|
- * }
|
|
|
- */
|
|
|
- var Throttler = (function () {
|
|
|
- function Throttler() {
|
|
|
- this.activePromise = null;
|
|
|
- this.queuedPromise = null;
|
|
|
- this.queuedPromiseFactory = null;
|
|
|
- }
|
|
|
- Throttler.prototype.queue = function (promiseFactory) {
|
|
|
- var _this = this;
|
|
|
- if (this.activePromise) {
|
|
|
- this.queuedPromiseFactory = promiseFactory;
|
|
|
- if (!this.queuedPromise) {
|
|
|
- var onComplete_1 = function () {
|
|
|
- _this.queuedPromise = null;
|
|
|
- var result = _this.queue(_this.queuedPromiseFactory);
|
|
|
- _this.queuedPromiseFactory = null;
|
|
|
- return result;
|
|
|
- };
|
|
|
- this.queuedPromise = new winjs_base_1.Promise(function (c, e, p) {
|
|
|
- _this.activePromise.then(onComplete_1, onComplete_1, p).done(c);
|
|
|
- }, function () {
|
|
|
- _this.activePromise.cancel();
|
|
|
- });
|
|
|
- }
|
|
|
- return new winjs_base_1.Promise(function (c, e, p) {
|
|
|
- _this.queuedPromise.then(c, e, p);
|
|
|
- }, function () {
|
|
|
- // no-op
|
|
|
- });
|
|
|
- }
|
|
|
- this.activePromise = promiseFactory();
|
|
|
- return new winjs_base_1.Promise(function (c, e, p) {
|
|
|
- _this.activePromise.done(function (result) {
|
|
|
- _this.activePromise = null;
|
|
|
- c(result);
|
|
|
- }, function (err) {
|
|
|
- _this.activePromise = null;
|
|
|
- e(err);
|
|
|
- }, p);
|
|
|
- }, function () {
|
|
|
- _this.activePromise.cancel();
|
|
|
- });
|
|
|
- };
|
|
|
- return Throttler;
|
|
|
- }());
|
|
|
- exports.Throttler = Throttler;
|
|
|
- // TODO@Joao: can the previous throttler be replaced with this?
|
|
|
- var SimpleThrottler = (function () {
|
|
|
- function SimpleThrottler() {
|
|
|
- this.current = winjs_base_1.TPromise.as(null);
|
|
|
- }
|
|
|
- SimpleThrottler.prototype.queue = function (promiseTask) {
|
|
|
- return this.current = this.current.then(function () { return promiseTask(); });
|
|
|
- };
|
|
|
- return SimpleThrottler;
|
|
|
- }());
|
|
|
- exports.SimpleThrottler = SimpleThrottler;
|
|
|
- /**
|
|
|
- * A helper to delay execution of a task that is being requested often.
|
|
|
- *
|
|
|
- * Following the throttler, now imagine the mail man wants to optimize the number of
|
|
|
- * trips proactively. The trip itself can be long, so the he decides not to make the trip
|
|
|
- * as soon as a letter is submitted. Instead he waits a while, in case more
|
|
|
- * letters are submitted. After said waiting period, if no letters were submitted, he
|
|
|
- * decides to make the trip. Imagine that N more letters were submitted after the first
|
|
|
- * one, all within a short period of time between each other. Even though N+1
|
|
|
- * submissions occurred, only 1 delivery was made.
|
|
|
- *
|
|
|
- * The delayer offers this behavior via the trigger() method, into which both the task
|
|
|
- * to be executed and the waiting period (delay) must be passed in as arguments. Following
|
|
|
- * the example:
|
|
|
- *
|
|
|
- * const delayer = new Delayer(WAITING_PERIOD);
|
|
|
- * const letters = [];
|
|
|
- *
|
|
|
- * function letterReceived(l) {
|
|
|
- * letters.push(l);
|
|
|
- * delayer.trigger(() => { return makeTheTrip(); });
|
|
|
- * }
|
|
|
- */
|
|
|
- var Delayer = (function () {
|
|
|
- function Delayer(defaultDelay) {
|
|
|
- this.defaultDelay = defaultDelay;
|
|
|
- this.timeout = null;
|
|
|
- this.completionPromise = null;
|
|
|
- this.onSuccess = null;
|
|
|
- this.task = null;
|
|
|
- }
|
|
|
- Delayer.prototype.trigger = function (task, delay) {
|
|
|
- var _this = this;
|
|
|
- if (delay === void 0) { delay = this.defaultDelay; }
|
|
|
- this.task = task;
|
|
|
- this.cancelTimeout();
|
|
|
- if (!this.completionPromise) {
|
|
|
- this.completionPromise = new winjs_base_1.Promise(function (c) {
|
|
|
- _this.onSuccess = c;
|
|
|
- }, function () {
|
|
|
- // no-op
|
|
|
- }).then(function () {
|
|
|
- _this.completionPromise = null;
|
|
|
- _this.onSuccess = null;
|
|
|
- var task = _this.task;
|
|
|
- _this.task = null;
|
|
|
- return task();
|
|
|
- });
|
|
|
- }
|
|
|
- this.timeout = setTimeout(function () {
|
|
|
- _this.timeout = null;
|
|
|
- _this.onSuccess(null);
|
|
|
- }, delay);
|
|
|
- return this.completionPromise;
|
|
|
- };
|
|
|
- Delayer.prototype.isTriggered = function () {
|
|
|
- return this.timeout !== null;
|
|
|
- };
|
|
|
- Delayer.prototype.cancel = function () {
|
|
|
- this.cancelTimeout();
|
|
|
- if (this.completionPromise) {
|
|
|
- this.completionPromise.cancel();
|
|
|
- this.completionPromise = null;
|
|
|
- }
|
|
|
- };
|
|
|
- Delayer.prototype.cancelTimeout = function () {
|
|
|
- if (this.timeout !== null) {
|
|
|
- clearTimeout(this.timeout);
|
|
|
- this.timeout = null;
|
|
|
- }
|
|
|
- };
|
|
|
- return Delayer;
|
|
|
- }());
|
|
|
- exports.Delayer = Delayer;
|
|
|
- /**
|
|
|
- * A helper to delay execution of a task that is being requested often, while
|
|
|
- * preventing accumulation of consecutive executions, while the task runs.
|
|
|
- *
|
|
|
- * Simply combine the two mail man strategies from the Throttler and Delayer
|
|
|
- * helpers, for an analogy.
|
|
|
- */
|
|
|
- var ThrottledDelayer = (function (_super) {
|
|
|
- __extends(ThrottledDelayer, _super);
|
|
|
- function ThrottledDelayer(defaultDelay) {
|
|
|
- var _this = _super.call(this, defaultDelay) || this;
|
|
|
- _this.throttler = new Throttler();
|
|
|
- return _this;
|
|
|
- }
|
|
|
- ThrottledDelayer.prototype.trigger = function (promiseFactory, delay) {
|
|
|
- var _this = this;
|
|
|
- return _super.prototype.trigger.call(this, function () { return _this.throttler.queue(promiseFactory); }, delay);
|
|
|
- };
|
|
|
- return ThrottledDelayer;
|
|
|
- }(Delayer));
|
|
|
- exports.ThrottledDelayer = ThrottledDelayer;
|
|
|
- /**
|
|
|
- * Similar to the ThrottledDelayer, except it also guarantees that the promise
|
|
|
- * factory doesn't get called more often than every `minimumPeriod` milliseconds.
|
|
|
- */
|
|
|
- var PeriodThrottledDelayer = (function (_super) {
|
|
|
- __extends(PeriodThrottledDelayer, _super);
|
|
|
- function PeriodThrottledDelayer(defaultDelay, minimumPeriod) {
|
|
|
- if (minimumPeriod === void 0) { minimumPeriod = 0; }
|
|
|
- var _this = _super.call(this, defaultDelay) || this;
|
|
|
- _this.minimumPeriod = minimumPeriod;
|
|
|
- _this.periodThrottler = new Throttler();
|
|
|
- return _this;
|
|
|
- }
|
|
|
- PeriodThrottledDelayer.prototype.trigger = function (promiseFactory, delay) {
|
|
|
- var _this = this;
|
|
|
- return _super.prototype.trigger.call(this, function () {
|
|
|
- return _this.periodThrottler.queue(function () {
|
|
|
- return winjs_base_1.Promise.join([
|
|
|
- winjs_base_1.TPromise.timeout(_this.minimumPeriod),
|
|
|
- promiseFactory()
|
|
|
- ]).then(function (r) { return r[1]; });
|
|
|
- });
|
|
|
- }, delay);
|
|
|
- };
|
|
|
- return PeriodThrottledDelayer;
|
|
|
- }(ThrottledDelayer));
|
|
|
- exports.PeriodThrottledDelayer = PeriodThrottledDelayer;
|
|
|
- var PromiseSource = (function () {
|
|
|
- function PromiseSource() {
|
|
|
- var _this = this;
|
|
|
- this._value = new winjs_base_1.TPromise(function (c, e) {
|
|
|
- _this._completeCallback = c;
|
|
|
- _this._errorCallback = e;
|
|
|
- });
|
|
|
- }
|
|
|
- Object.defineProperty(PromiseSource.prototype, "value", {
|
|
|
- get: function () {
|
|
|
- return this._value;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- PromiseSource.prototype.complete = function (value) {
|
|
|
- this._completeCallback(value);
|
|
|
- };
|
|
|
- PromiseSource.prototype.error = function (err) {
|
|
|
- this._errorCallback(err);
|
|
|
- };
|
|
|
- return PromiseSource;
|
|
|
- }());
|
|
|
- exports.PromiseSource = PromiseSource;
|
|
|
- var ShallowCancelThenPromise = (function (_super) {
|
|
|
- __extends(ShallowCancelThenPromise, _super);
|
|
|
- function ShallowCancelThenPromise(outer) {
|
|
|
- var _this = this;
|
|
|
- var completeCallback, errorCallback, progressCallback;
|
|
|
- _this = _super.call(this, function (c, e, p) {
|
|
|
- completeCallback = c;
|
|
|
- errorCallback = e;
|
|
|
- progressCallback = p;
|
|
|
- }, function () {
|
|
|
- // cancel this promise but not the
|
|
|
- // outer promise
|
|
|
- errorCallback(errors.canceled());
|
|
|
- }) || this;
|
|
|
- outer.then(completeCallback, errorCallback, progressCallback);
|
|
|
- return _this;
|
|
|
- }
|
|
|
- return ShallowCancelThenPromise;
|
|
|
- }(winjs_base_1.TPromise));
|
|
|
- exports.ShallowCancelThenPromise = ShallowCancelThenPromise;
|
|
|
- /**
|
|
|
- * Returns a new promise that joins the provided promise. Upon completion of
|
|
|
- * the provided promise the provided function will always be called. This
|
|
|
- * method is comparable to a try-finally code block.
|
|
|
- * @param promise a promise
|
|
|
- * @param f a function that will be call in the success and error case.
|
|
|
- */
|
|
|
- function always(promise, f) {
|
|
|
- return new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- promise.done(function (result) {
|
|
|
- try {
|
|
|
- f(result);
|
|
|
- }
|
|
|
- catch (e1) {
|
|
|
- errors.onUnexpectedError(e1);
|
|
|
- }
|
|
|
- c(result);
|
|
|
- }, function (err) {
|
|
|
- try {
|
|
|
- f(err);
|
|
|
- }
|
|
|
- catch (e1) {
|
|
|
- errors.onUnexpectedError(e1);
|
|
|
- }
|
|
|
- e(err);
|
|
|
- }, function (progress) {
|
|
|
- p(progress);
|
|
|
- });
|
|
|
- }, function () {
|
|
|
- promise.cancel();
|
|
|
- });
|
|
|
- }
|
|
|
- exports.always = always;
|
|
|
- /**
|
|
|
- * Runs the provided list of promise factories in sequential order. The returned
|
|
|
- * promise will complete to an array of results from each promise.
|
|
|
- */
|
|
|
- function sequence(promiseFactories) {
|
|
|
- var results = [];
|
|
|
- // reverse since we start with last element using pop()
|
|
|
- promiseFactories = promiseFactories.reverse();
|
|
|
- function next() {
|
|
|
- if (promiseFactories.length) {
|
|
|
- return promiseFactories.pop()();
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- function thenHandler(result) {
|
|
|
- if (result !== undefined && result !== null) {
|
|
|
- results.push(result);
|
|
|
- }
|
|
|
- var n = next();
|
|
|
- if (n) {
|
|
|
- return n.then(thenHandler);
|
|
|
- }
|
|
|
- return winjs_base_1.TPromise.as(results);
|
|
|
- }
|
|
|
- return winjs_base_1.TPromise.as(null).then(thenHandler);
|
|
|
- }
|
|
|
- exports.sequence = sequence;
|
|
|
- function first(promiseFactories, shouldStop) {
|
|
|
- if (shouldStop === void 0) { shouldStop = function (t) { return !!t; }; }
|
|
|
- promiseFactories = promiseFactories.reverse().slice();
|
|
|
- var loop = function () {
|
|
|
- if (promiseFactories.length === 0) {
|
|
|
- return winjs_base_1.TPromise.as(null);
|
|
|
- }
|
|
|
- var factory = promiseFactories.pop();
|
|
|
- var promise = factory();
|
|
|
- return promise.then(function (result) {
|
|
|
- if (shouldStop(result)) {
|
|
|
- return winjs_base_1.TPromise.as(result);
|
|
|
- }
|
|
|
- return loop();
|
|
|
- });
|
|
|
- };
|
|
|
- return loop();
|
|
|
- }
|
|
|
- exports.first = first;
|
|
|
- /**
|
|
|
- * A helper to queue N promises and run them all with a max degree of parallelism. The helper
|
|
|
- * ensures that at any time no more than M promises are running at the same time.
|
|
|
- */
|
|
|
- var Limiter = (function () {
|
|
|
- function Limiter(maxDegreeOfParalellism) {
|
|
|
- this.maxDegreeOfParalellism = maxDegreeOfParalellism;
|
|
|
- this.outstandingPromises = [];
|
|
|
- this.runningPromises = 0;
|
|
|
- this._onFinished = new event_1.Emitter();
|
|
|
- }
|
|
|
- Object.defineProperty(Limiter.prototype, "onFinished", {
|
|
|
- get: function () {
|
|
|
- return this._onFinished.event;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Limiter.prototype.queue = function (promiseFactory) {
|
|
|
- var _this = this;
|
|
|
- return new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- _this.outstandingPromises.push({
|
|
|
- factory: promiseFactory,
|
|
|
- c: c,
|
|
|
- e: e,
|
|
|
- p: p
|
|
|
- });
|
|
|
- _this.consume();
|
|
|
- });
|
|
|
- };
|
|
|
- Limiter.prototype.consume = function () {
|
|
|
- var _this = this;
|
|
|
- while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
|
|
|
- var iLimitedTask = this.outstandingPromises.shift();
|
|
|
- this.runningPromises++;
|
|
|
- var promise = iLimitedTask.factory();
|
|
|
- promise.done(iLimitedTask.c, iLimitedTask.e, iLimitedTask.p);
|
|
|
- promise.done(function () { return _this.consumed(); }, function () { return _this.consumed(); });
|
|
|
- }
|
|
|
- };
|
|
|
- Limiter.prototype.consumed = function () {
|
|
|
- this.runningPromises--;
|
|
|
- if (this.outstandingPromises.length > 0) {
|
|
|
- this.consume();
|
|
|
- }
|
|
|
- else {
|
|
|
- this._onFinished.fire();
|
|
|
- }
|
|
|
- };
|
|
|
- Limiter.prototype.dispose = function () {
|
|
|
- this._onFinished.dispose();
|
|
|
- };
|
|
|
- return Limiter;
|
|
|
- }());
|
|
|
- exports.Limiter = Limiter;
|
|
|
- /**
|
|
|
- * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
|
|
|
- */
|
|
|
- var Queue = (function (_super) {
|
|
|
- __extends(Queue, _super);
|
|
|
- function Queue() {
|
|
|
- return _super.call(this, 1) || this;
|
|
|
- }
|
|
|
- return Queue;
|
|
|
- }(Limiter));
|
|
|
- exports.Queue = Queue;
|
|
|
- function setDisposableTimeout(handler, timeout) {
|
|
|
- var args = [];
|
|
|
- for (var _i = 2; _i < arguments.length; _i++) {
|
|
|
- args[_i - 2] = arguments[_i];
|
|
|
- }
|
|
|
- var handle = setTimeout.apply(void 0, [handler, timeout].concat(args));
|
|
|
- return { dispose: function () { clearTimeout(handle); } };
|
|
|
- }
|
|
|
- exports.setDisposableTimeout = setDisposableTimeout;
|
|
|
- var TimeoutTimer = (function (_super) {
|
|
|
- __extends(TimeoutTimer, _super);
|
|
|
- function TimeoutTimer() {
|
|
|
- var _this = _super.call(this) || this;
|
|
|
- _this._token = -1;
|
|
|
- return _this;
|
|
|
- }
|
|
|
- TimeoutTimer.prototype.dispose = function () {
|
|
|
- this.cancel();
|
|
|
- _super.prototype.dispose.call(this);
|
|
|
- };
|
|
|
- TimeoutTimer.prototype.cancel = function () {
|
|
|
- if (this._token !== -1) {
|
|
|
- platform.clearTimeout(this._token);
|
|
|
- this._token = -1;
|
|
|
- }
|
|
|
- };
|
|
|
- TimeoutTimer.prototype.cancelAndSet = function (runner, timeout) {
|
|
|
- var _this = this;
|
|
|
- this.cancel();
|
|
|
- this._token = platform.setTimeout(function () {
|
|
|
- _this._token = -1;
|
|
|
- runner();
|
|
|
- }, timeout);
|
|
|
- };
|
|
|
- TimeoutTimer.prototype.setIfNotSet = function (runner, timeout) {
|
|
|
- var _this = this;
|
|
|
- if (this._token !== -1) {
|
|
|
- // timer is already set
|
|
|
- return;
|
|
|
- }
|
|
|
- this._token = platform.setTimeout(function () {
|
|
|
- _this._token = -1;
|
|
|
- runner();
|
|
|
- }, timeout);
|
|
|
- };
|
|
|
- return TimeoutTimer;
|
|
|
- }(lifecycle_1.Disposable));
|
|
|
- exports.TimeoutTimer = TimeoutTimer;
|
|
|
- var IntervalTimer = (function (_super) {
|
|
|
- __extends(IntervalTimer, _super);
|
|
|
- function IntervalTimer() {
|
|
|
- var _this = _super.call(this) || this;
|
|
|
- _this._token = -1;
|
|
|
- return _this;
|
|
|
- }
|
|
|
- IntervalTimer.prototype.dispose = function () {
|
|
|
- this.cancel();
|
|
|
- _super.prototype.dispose.call(this);
|
|
|
- };
|
|
|
- IntervalTimer.prototype.cancel = function () {
|
|
|
- if (this._token !== -1) {
|
|
|
- platform.clearInterval(this._token);
|
|
|
- this._token = -1;
|
|
|
- }
|
|
|
- };
|
|
|
- IntervalTimer.prototype.cancelAndSet = function (runner, interval) {
|
|
|
- this.cancel();
|
|
|
- this._token = platform.setInterval(function () {
|
|
|
- runner();
|
|
|
- }, interval);
|
|
|
- };
|
|
|
- return IntervalTimer;
|
|
|
- }(lifecycle_1.Disposable));
|
|
|
- exports.IntervalTimer = IntervalTimer;
|
|
|
- var RunOnceScheduler = (function () {
|
|
|
- function RunOnceScheduler(runner, timeout) {
|
|
|
- this.timeoutToken = -1;
|
|
|
- this.runner = runner;
|
|
|
- this.timeout = timeout;
|
|
|
- this.timeoutHandler = this.onTimeout.bind(this);
|
|
|
- }
|
|
|
- /**
|
|
|
- * Dispose RunOnceScheduler
|
|
|
- */
|
|
|
- RunOnceScheduler.prototype.dispose = function () {
|
|
|
- this.cancel();
|
|
|
- this.runner = null;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Cancel current scheduled runner (if any).
|
|
|
- */
|
|
|
- RunOnceScheduler.prototype.cancel = function () {
|
|
|
- if (this.isScheduled()) {
|
|
|
- platform.clearTimeout(this.timeoutToken);
|
|
|
- this.timeoutToken = -1;
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * Replace runner. If there is a runner already scheduled, the new runner will be called.
|
|
|
- */
|
|
|
- RunOnceScheduler.prototype.setRunner = function (runner) {
|
|
|
- this.runner = runner;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Cancel previous runner (if any) & schedule a new runner.
|
|
|
- */
|
|
|
- RunOnceScheduler.prototype.schedule = function (delay) {
|
|
|
- if (delay === void 0) { delay = this.timeout; }
|
|
|
- this.cancel();
|
|
|
- this.timeoutToken = platform.setTimeout(this.timeoutHandler, delay);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Returns true if scheduled.
|
|
|
- */
|
|
|
- RunOnceScheduler.prototype.isScheduled = function () {
|
|
|
- return this.timeoutToken !== -1;
|
|
|
- };
|
|
|
- RunOnceScheduler.prototype.onTimeout = function () {
|
|
|
- this.timeoutToken = -1;
|
|
|
- if (this.runner) {
|
|
|
- this.runner();
|
|
|
- }
|
|
|
- };
|
|
|
- return RunOnceScheduler;
|
|
|
- }());
|
|
|
- exports.RunOnceScheduler = RunOnceScheduler;
|
|
|
- function nfcall(fn) {
|
|
|
- var args = [];
|
|
|
- for (var _i = 1; _i < arguments.length; _i++) {
|
|
|
- args[_i - 1] = arguments[_i];
|
|
|
- }
|
|
|
- return new winjs_base_1.Promise(function (c, e) { return fn.apply(void 0, args.concat([function (err, result) { return err ? e(err) : c(result); }])); }, function () { return null; });
|
|
|
- }
|
|
|
- exports.nfcall = nfcall;
|
|
|
- function ninvoke(thisArg, fn) {
|
|
|
- var args = [];
|
|
|
- for (var _i = 2; _i < arguments.length; _i++) {
|
|
|
- args[_i - 2] = arguments[_i];
|
|
|
- }
|
|
|
- return new winjs_base_1.Promise(function (c, e) { return fn.call.apply(fn, [thisArg].concat(args, [function (err, result) { return err ? e(err) : c(result); }])); }, function () { return null; });
|
|
|
- }
|
|
|
- exports.ninvoke = ninvoke;
|
|
|
-});
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-define(__m[31/*vs/base/common/worker/simpleWorker*/], __M([1/*require*/,0/*exports*/,8/*vs/base/common/errors*/,10/*vs/base/common/lifecycle*/,2/*vs/base/common/winjs.base*/,18/*vs/base/common/async*/,4/*vs/base/common/platform*/]), function (require, exports, errors_1, lifecycle_1, winjs_base_1, async_1, platform_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var INITIALIZE = '$initialize';
|
|
|
- var webWorkerWarningLogged = false;
|
|
|
- function logOnceWebWorkerWarning(err) {
|
|
|
- if (!platform_1.isWeb) {
|
|
|
- // running tests
|
|
|
- return;
|
|
|
- }
|
|
|
- if (!webWorkerWarningLogged) {
|
|
|
- webWorkerWarningLogged = true;
|
|
|
- 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');
|
|
|
- }
|
|
|
- console.warn(err.message);
|
|
|
- }
|
|
|
- exports.logOnceWebWorkerWarning = logOnceWebWorkerWarning;
|
|
|
- var SimpleWorkerProtocol = (function () {
|
|
|
- function SimpleWorkerProtocol(handler) {
|
|
|
- this._workerId = -1;
|
|
|
- this._handler = handler;
|
|
|
- this._lastSentReq = 0;
|
|
|
- this._pendingReplies = Object.create(null);
|
|
|
- }
|
|
|
- SimpleWorkerProtocol.prototype.setWorkerId = function (workerId) {
|
|
|
- this._workerId = workerId;
|
|
|
- };
|
|
|
- SimpleWorkerProtocol.prototype.sendMessage = function (method, args) {
|
|
|
- var req = String(++this._lastSentReq);
|
|
|
- var reply = {
|
|
|
- c: null,
|
|
|
- e: null
|
|
|
- };
|
|
|
- var result = new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- reply.c = c;
|
|
|
- reply.e = e;
|
|
|
- }, function () {
|
|
|
- // Cancel not supported
|
|
|
- });
|
|
|
- this._pendingReplies[req] = reply;
|
|
|
- this._send({
|
|
|
- vsWorker: this._workerId,
|
|
|
- req: req,
|
|
|
- method: method,
|
|
|
- args: args
|
|
|
- });
|
|
|
- return result;
|
|
|
- };
|
|
|
- SimpleWorkerProtocol.prototype.handleMessage = function (serializedMessage) {
|
|
|
- var message;
|
|
|
- try {
|
|
|
- message = JSON.parse(serializedMessage);
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- // nothing
|
|
|
- }
|
|
|
- if (!message.vsWorker) {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (this._workerId !== -1 && message.vsWorker !== this._workerId) {
|
|
|
- return;
|
|
|
- }
|
|
|
- this._handleMessage(message);
|
|
|
- };
|
|
|
- SimpleWorkerProtocol.prototype._handleMessage = function (msg) {
|
|
|
- var _this = this;
|
|
|
- if (msg.seq) {
|
|
|
- var replyMessage = msg;
|
|
|
- if (!this._pendingReplies[replyMessage.seq]) {
|
|
|
- console.warn('Got reply to unknown seq');
|
|
|
- return;
|
|
|
- }
|
|
|
- var reply = this._pendingReplies[replyMessage.seq];
|
|
|
- delete this._pendingReplies[replyMessage.seq];
|
|
|
- if (replyMessage.err) {
|
|
|
- var err = replyMessage.err;
|
|
|
- if (replyMessage.err.$isError) {
|
|
|
- err = new Error();
|
|
|
- err.name = replyMessage.err.name;
|
|
|
- err.message = replyMessage.err.message;
|
|
|
- err.stack = replyMessage.err.stack;
|
|
|
- }
|
|
|
- reply.e(err);
|
|
|
- return;
|
|
|
- }
|
|
|
- reply.c(replyMessage.res);
|
|
|
- return;
|
|
|
- }
|
|
|
- var requestMessage = msg;
|
|
|
- var req = requestMessage.req;
|
|
|
- var result = this._handler.handleMessage(requestMessage.method, requestMessage.args);
|
|
|
- result.then(function (r) {
|
|
|
- _this._send({
|
|
|
- vsWorker: _this._workerId,
|
|
|
- seq: req,
|
|
|
- res: r,
|
|
|
- err: undefined
|
|
|
- });
|
|
|
- }, function (e) {
|
|
|
- _this._send({
|
|
|
- vsWorker: _this._workerId,
|
|
|
- seq: req,
|
|
|
- res: undefined,
|
|
|
- err: errors_1.transformErrorForSerialization(e)
|
|
|
- });
|
|
|
- });
|
|
|
- };
|
|
|
- SimpleWorkerProtocol.prototype._send = function (msg) {
|
|
|
- var strMsg = JSON.stringify(msg);
|
|
|
- // console.log('SENDING: ' + strMsg);
|
|
|
- this._handler.sendMessage(strMsg);
|
|
|
- };
|
|
|
- return SimpleWorkerProtocol;
|
|
|
- }());
|
|
|
- /**
|
|
|
- * Main thread side
|
|
|
- */
|
|
|
- var SimpleWorkerClient = (function (_super) {
|
|
|
- __extends(SimpleWorkerClient, _super);
|
|
|
- function SimpleWorkerClient(workerFactory, moduleId) {
|
|
|
- var _this = _super.call(this) || this;
|
|
|
- _this._lastRequestTimestamp = -1;
|
|
|
- var lazyProxyFulfill = null;
|
|
|
- var lazyProxyReject = null;
|
|
|
- _this._worker = _this._register(workerFactory.create('vs/base/common/worker/simpleWorker', function (msg) {
|
|
|
- _this._protocol.handleMessage(msg);
|
|
|
- }, function (err) {
|
|
|
- // in Firefox, web workers fail lazily :(
|
|
|
- // we will reject the proxy
|
|
|
- lazyProxyReject(err);
|
|
|
- }));
|
|
|
- _this._protocol = new SimpleWorkerProtocol({
|
|
|
- sendMessage: function (msg) {
|
|
|
- _this._worker.postMessage(msg);
|
|
|
- },
|
|
|
- handleMessage: function (method, args) {
|
|
|
- // Intentionally not supporting worker -> main requests
|
|
|
- return winjs_base_1.TPromise.as(null);
|
|
|
- }
|
|
|
- });
|
|
|
- _this._protocol.setWorkerId(_this._worker.getId());
|
|
|
- // Gather loader configuration
|
|
|
- var loaderConfiguration = null;
|
|
|
- var globalRequire = self.require;
|
|
|
- if (typeof globalRequire.getConfig === 'function') {
|
|
|
- // Get the configuration from the Monaco AMD Loader
|
|
|
- loaderConfiguration = globalRequire.getConfig();
|
|
|
- }
|
|
|
- else if (typeof self.requirejs !== 'undefined') {
|
|
|
- // Get the configuration from requirejs
|
|
|
- loaderConfiguration = self.requirejs.s.contexts._.config;
|
|
|
- }
|
|
|
- _this._lazyProxy = new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- lazyProxyFulfill = c;
|
|
|
- lazyProxyReject = e;
|
|
|
- }, function () { });
|
|
|
- // Send initialize message
|
|
|
- _this._onModuleLoaded = _this._protocol.sendMessage(INITIALIZE, [
|
|
|
- _this._worker.getId(),
|
|
|
- moduleId,
|
|
|
- loaderConfiguration
|
|
|
- ]);
|
|
|
- _this._onModuleLoaded.then(function (availableMethods) {
|
|
|
- var proxy = {};
|
|
|
- for (var i = 0; i < availableMethods.length; i++) {
|
|
|
- proxy[availableMethods[i]] = createProxyMethod(availableMethods[i], proxyMethodRequest);
|
|
|
- }
|
|
|
- lazyProxyFulfill(proxy);
|
|
|
- }, function (e) {
|
|
|
- lazyProxyReject(e);
|
|
|
- _this._onError('Worker failed to load ' + moduleId, e);
|
|
|
- });
|
|
|
- // Create proxy to loaded code
|
|
|
- var proxyMethodRequest = function (method, args) {
|
|
|
- return _this._request(method, args);
|
|
|
- };
|
|
|
- var createProxyMethod = function (method, proxyMethodRequest) {
|
|
|
- return function () {
|
|
|
- var args = Array.prototype.slice.call(arguments, 0);
|
|
|
- return proxyMethodRequest(method, args);
|
|
|
- };
|
|
|
- };
|
|
|
- return _this;
|
|
|
- }
|
|
|
- SimpleWorkerClient.prototype.getProxyObject = function () {
|
|
|
- // Do not allow chaining promises to cancel the proxy creation
|
|
|
- return new async_1.ShallowCancelThenPromise(this._lazyProxy);
|
|
|
- };
|
|
|
- SimpleWorkerClient.prototype.getLastRequestTimestamp = function () {
|
|
|
- return this._lastRequestTimestamp;
|
|
|
- };
|
|
|
- SimpleWorkerClient.prototype._request = function (method, args) {
|
|
|
- var _this = this;
|
|
|
- return new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- _this._onModuleLoaded.then(function () {
|
|
|
- _this._lastRequestTimestamp = Date.now();
|
|
|
- _this._protocol.sendMessage(method, args).then(c, e);
|
|
|
- }, e);
|
|
|
- }, function () {
|
|
|
- // Cancel intentionally not supported
|
|
|
- });
|
|
|
- };
|
|
|
- SimpleWorkerClient.prototype._onError = function (message, error) {
|
|
|
- console.error(message);
|
|
|
- console.info(error);
|
|
|
- };
|
|
|
- return SimpleWorkerClient;
|
|
|
- }(lifecycle_1.Disposable));
|
|
|
- exports.SimpleWorkerClient = SimpleWorkerClient;
|
|
|
- /**
|
|
|
- * Worker side
|
|
|
- */
|
|
|
- var SimpleWorkerServer = (function () {
|
|
|
- function SimpleWorkerServer(postSerializedMessage) {
|
|
|
- var _this = this;
|
|
|
- this._protocol = new SimpleWorkerProtocol({
|
|
|
- sendMessage: function (msg) {
|
|
|
- postSerializedMessage(msg);
|
|
|
- },
|
|
|
- handleMessage: function (method, args) { return _this._handleMessage(method, args); }
|
|
|
- });
|
|
|
- }
|
|
|
- SimpleWorkerServer.prototype.onmessage = function (msg) {
|
|
|
- this._protocol.handleMessage(msg);
|
|
|
- };
|
|
|
- SimpleWorkerServer.prototype._handleMessage = function (method, args) {
|
|
|
- if (method === INITIALIZE) {
|
|
|
- return this.initialize(args[0], args[1], args[2]);
|
|
|
- }
|
|
|
- if (!this._requestHandler || typeof this._requestHandler[method] !== 'function') {
|
|
|
- return winjs_base_1.TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
|
|
|
- }
|
|
|
- try {
|
|
|
- return winjs_base_1.TPromise.as(this._requestHandler[method].apply(this._requestHandler, args));
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- return winjs_base_1.TPromise.wrapError(e);
|
|
|
- }
|
|
|
- };
|
|
|
- SimpleWorkerServer.prototype.initialize = function (workerId, moduleId, loaderConfig) {
|
|
|
- var _this = this;
|
|
|
- this._protocol.setWorkerId(workerId);
|
|
|
- if (loaderConfig) {
|
|
|
- // Remove 'baseUrl', handling it is beyond scope for now
|
|
|
- if (typeof loaderConfig.baseUrl !== 'undefined') {
|
|
|
- delete loaderConfig['baseUrl'];
|
|
|
- }
|
|
|
- if (typeof loaderConfig.paths !== 'undefined') {
|
|
|
- if (typeof loaderConfig.paths.vs !== 'undefined') {
|
|
|
- delete loaderConfig.paths['vs'];
|
|
|
- }
|
|
|
- }
|
|
|
- var nlsConfig_1 = loaderConfig['vs/nls'];
|
|
|
- // We need to have pseudo translation
|
|
|
- if (nlsConfig_1 && nlsConfig_1.pseudo) {
|
|
|
- require(['vs/nls'], function (nlsPlugin) {
|
|
|
- nlsPlugin.setPseudoTranslation(nlsConfig_1.pseudo);
|
|
|
- });
|
|
|
- }
|
|
|
- // Since this is in a web worker, enable catching errors
|
|
|
- loaderConfig.catchError = true;
|
|
|
- self.require.config(loaderConfig);
|
|
|
- }
|
|
|
- var cc;
|
|
|
- var ee;
|
|
|
- var r = new winjs_base_1.TPromise(function (c, e, p) {
|
|
|
- cc = c;
|
|
|
- ee = e;
|
|
|
- });
|
|
|
- // Use the global require to be sure to get the global config
|
|
|
- self.require([moduleId], function () {
|
|
|
- var result = [];
|
|
|
- for (var _i = 0; _i < arguments.length; _i++) {
|
|
|
- result[_i] = arguments[_i];
|
|
|
- }
|
|
|
- var handlerModule = result[0];
|
|
|
- _this._requestHandler = handlerModule.create();
|
|
|
- var methods = [];
|
|
|
- for (var prop in _this._requestHandler) {
|
|
|
- if (typeof _this._requestHandler[prop] === 'function') {
|
|
|
- methods.push(prop);
|
|
|
- }
|
|
|
- }
|
|
|
- cc(methods);
|
|
|
- }, ee);
|
|
|
- return r;
|
|
|
- };
|
|
|
- return SimpleWorkerServer;
|
|
|
- }());
|
|
|
- exports.SimpleWorkerServer = SimpleWorkerServer;
|
|
|
- /**
|
|
|
- * Called on the worker side
|
|
|
- */
|
|
|
- function create(postMessage) {
|
|
|
- return new SimpleWorkerServer(postMessage);
|
|
|
- }
|
|
|
- exports.create = create;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[3/*vs/editor/common/core/position*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * A position in the editor.
|
|
|
- */
|
|
|
- var Position = (function () {
|
|
|
- function Position(lineNumber, column) {
|
|
|
- this.lineNumber = lineNumber;
|
|
|
- this.column = column;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Test if this position equals other position
|
|
|
- */
|
|
|
- Position.prototype.equals = function (other) {
|
|
|
- return Position.equals(this, other);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if position `a` equals position `b`
|
|
|
- */
|
|
|
- Position.equals = function (a, b) {
|
|
|
- if (!a && !b) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- return (!!a &&
|
|
|
- !!b &&
|
|
|
- a.lineNumber === b.lineNumber &&
|
|
|
- a.column === b.column);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if this position is before other position.
|
|
|
- * If the two positions are equal, the result will be false.
|
|
|
- */
|
|
|
- Position.prototype.isBefore = function (other) {
|
|
|
- return Position.isBefore(this, other);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if position `a` is before position `b`.
|
|
|
- * If the two positions are equal, the result will be false.
|
|
|
- */
|
|
|
- Position.isBefore = function (a, b) {
|
|
|
- if (a.lineNumber < b.lineNumber) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (b.lineNumber < a.lineNumber) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return a.column < b.column;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if this position is before other position.
|
|
|
- * If the two positions are equal, the result will be true.
|
|
|
- */
|
|
|
- Position.prototype.isBeforeOrEqual = function (other) {
|
|
|
- return Position.isBeforeOrEqual(this, other);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if position `a` is before position `b`.
|
|
|
- * If the two positions are equal, the result will be true.
|
|
|
- */
|
|
|
- Position.isBeforeOrEqual = function (a, b) {
|
|
|
- if (a.lineNumber < b.lineNumber) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (b.lineNumber < a.lineNumber) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return a.column <= b.column;
|
|
|
- };
|
|
|
- /**
|
|
|
- * A function that compares positions, useful for sorting
|
|
|
- */
|
|
|
- Position.compare = function (a, b) {
|
|
|
- var aLineNumber = a.lineNumber | 0;
|
|
|
- var bLineNumber = b.lineNumber | 0;
|
|
|
- if (aLineNumber === bLineNumber) {
|
|
|
- var aColumn = a.column | 0;
|
|
|
- var bColumn = b.column | 0;
|
|
|
- return aColumn - bColumn;
|
|
|
- }
|
|
|
- return aLineNumber - bLineNumber;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Clone this position.
|
|
|
- */
|
|
|
- Position.prototype.clone = function () {
|
|
|
- return new Position(this.lineNumber, this.column);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Convert to a human-readable representation.
|
|
|
- */
|
|
|
- Position.prototype.toString = function () {
|
|
|
- return '(' + this.lineNumber + ',' + this.column + ')';
|
|
|
- };
|
|
|
- // ---
|
|
|
- /**
|
|
|
- * Create a `Position` from an `IPosition`.
|
|
|
- */
|
|
|
- Position.lift = function (pos) {
|
|
|
- return new Position(pos.lineNumber, pos.column);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `obj` is an `IPosition`.
|
|
|
- */
|
|
|
- Position.isIPosition = function (obj) {
|
|
|
- return (obj
|
|
|
- && (typeof obj.lineNumber === 'number')
|
|
|
- && (typeof obj.column === 'number'));
|
|
|
- };
|
|
|
- return Position;
|
|
|
- }());
|
|
|
- exports.Position = Position;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-define(__m[5/*vs/editor/common/core/range*/], __M([1/*require*/,0/*exports*/,3/*vs/editor/common/core/position*/]), function (require, exports, position_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)
|
|
|
- */
|
|
|
- var Range = (function () {
|
|
|
- function Range(startLineNumber, startColumn, endLineNumber, endColumn) {
|
|
|
- if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {
|
|
|
- this.startLineNumber = endLineNumber;
|
|
|
- this.startColumn = endColumn;
|
|
|
- this.endLineNumber = startLineNumber;
|
|
|
- this.endColumn = startColumn;
|
|
|
- }
|
|
|
- else {
|
|
|
- this.startLineNumber = startLineNumber;
|
|
|
- this.startColumn = startColumn;
|
|
|
- this.endLineNumber = endLineNumber;
|
|
|
- this.endColumn = endColumn;
|
|
|
- }
|
|
|
- }
|
|
|
- /**
|
|
|
- * Test if this range is empty.
|
|
|
- */
|
|
|
- Range.prototype.isEmpty = function () {
|
|
|
- return Range.isEmpty(this);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `range` is empty.
|
|
|
- */
|
|
|
- Range.isEmpty = function (range) {
|
|
|
- return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if position is in this range. If the position is at the edges, will return true.
|
|
|
- */
|
|
|
- Range.prototype.containsPosition = function (position) {
|
|
|
- return Range.containsPosition(this, position);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `position` is in `range`. If the position is at the edges, will return true.
|
|
|
- */
|
|
|
- Range.containsPosition = function (range, position) {
|
|
|
- if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if range is in this range. If the range is equal to this range, will return true.
|
|
|
- */
|
|
|
- Range.prototype.containsRange = function (range) {
|
|
|
- return Range.containsRange(this, range);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `otherRange` is in `range`. If the ranges are equal, will return true.
|
|
|
- */
|
|
|
- Range.containsRange = function (range, otherRange) {
|
|
|
- if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- /**
|
|
|
- * A reunion of the two ranges.
|
|
|
- * The smallest position will be used as the start point, and the largest one as the end point.
|
|
|
- */
|
|
|
- Range.prototype.plusRange = function (range) {
|
|
|
- return Range.plusRange(this, range);
|
|
|
- };
|
|
|
- /**
|
|
|
- * A reunion of the two ranges.
|
|
|
- * The smallest position will be used as the start point, and the largest one as the end point.
|
|
|
- */
|
|
|
- Range.plusRange = function (a, b) {
|
|
|
- var startLineNumber, startColumn, endLineNumber, endColumn;
|
|
|
- if (b.startLineNumber < a.startLineNumber) {
|
|
|
- startLineNumber = b.startLineNumber;
|
|
|
- startColumn = b.startColumn;
|
|
|
- }
|
|
|
- else if (b.startLineNumber === a.startLineNumber) {
|
|
|
- startLineNumber = b.startLineNumber;
|
|
|
- startColumn = Math.min(b.startColumn, a.startColumn);
|
|
|
- }
|
|
|
- else {
|
|
|
- startLineNumber = a.startLineNumber;
|
|
|
- startColumn = a.startColumn;
|
|
|
- }
|
|
|
- if (b.endLineNumber > a.endLineNumber) {
|
|
|
- endLineNumber = b.endLineNumber;
|
|
|
- endColumn = b.endColumn;
|
|
|
- }
|
|
|
- else if (b.endLineNumber === a.endLineNumber) {
|
|
|
- endLineNumber = b.endLineNumber;
|
|
|
- endColumn = Math.max(b.endColumn, a.endColumn);
|
|
|
- }
|
|
|
- else {
|
|
|
- endLineNumber = a.endLineNumber;
|
|
|
- endColumn = a.endColumn;
|
|
|
- }
|
|
|
- return new Range(startLineNumber, startColumn, endLineNumber, endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * A intersection of the two ranges.
|
|
|
- */
|
|
|
- Range.prototype.intersectRanges = function (range) {
|
|
|
- return Range.intersectRanges(this, range);
|
|
|
- };
|
|
|
- /**
|
|
|
- * A intersection of the two ranges.
|
|
|
- */
|
|
|
- Range.intersectRanges = function (a, b) {
|
|
|
- var resultStartLineNumber = a.startLineNumber, resultStartColumn = a.startColumn, resultEndLineNumber = a.endLineNumber, resultEndColumn = a.endColumn, otherStartLineNumber = b.startLineNumber, otherStartColumn = b.startColumn, otherEndLineNumber = b.endLineNumber, otherEndColumn = b.endColumn;
|
|
|
- if (resultStartLineNumber < otherStartLineNumber) {
|
|
|
- resultStartLineNumber = otherStartLineNumber;
|
|
|
- resultStartColumn = otherStartColumn;
|
|
|
- }
|
|
|
- else if (resultStartLineNumber === otherStartLineNumber) {
|
|
|
- resultStartColumn = Math.max(resultStartColumn, otherStartColumn);
|
|
|
- }
|
|
|
- if (resultEndLineNumber > otherEndLineNumber) {
|
|
|
- resultEndLineNumber = otherEndLineNumber;
|
|
|
- resultEndColumn = otherEndColumn;
|
|
|
- }
|
|
|
- else if (resultEndLineNumber === otherEndLineNumber) {
|
|
|
- resultEndColumn = Math.min(resultEndColumn, otherEndColumn);
|
|
|
- }
|
|
|
- // Check if selection is now empty
|
|
|
- if (resultStartLineNumber > resultEndLineNumber) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if this range equals other.
|
|
|
- */
|
|
|
- Range.prototype.equalsRange = function (other) {
|
|
|
- return Range.equalsRange(this, other);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if range `a` equals `b`.
|
|
|
- */
|
|
|
- Range.equalsRange = function (a, b) {
|
|
|
- return (!!a &&
|
|
|
- !!b &&
|
|
|
- a.startLineNumber === b.startLineNumber &&
|
|
|
- a.startColumn === b.startColumn &&
|
|
|
- a.endLineNumber === b.endLineNumber &&
|
|
|
- a.endColumn === b.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Return the end position (which will be after or equal to the start position)
|
|
|
- */
|
|
|
- Range.prototype.getEndPosition = function () {
|
|
|
- return new position_1.Position(this.endLineNumber, this.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Return the start position (which will be before or equal to the end position)
|
|
|
- */
|
|
|
- Range.prototype.getStartPosition = function () {
|
|
|
- return new position_1.Position(this.startLineNumber, this.startColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Clone this range.
|
|
|
- */
|
|
|
- Range.prototype.cloneRange = function () {
|
|
|
- return new Range(this.startLineNumber, this.startColumn, this.endLineNumber, this.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Transform to a user presentable string representation.
|
|
|
- */
|
|
|
- Range.prototype.toString = function () {
|
|
|
- return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.
|
|
|
- */
|
|
|
- Range.prototype.setEndPosition = function (endLineNumber, endColumn) {
|
|
|
- return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.
|
|
|
- */
|
|
|
- Range.prototype.setStartPosition = function (startLineNumber, startColumn) {
|
|
|
- return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new empty range using this range's start position.
|
|
|
- */
|
|
|
- Range.prototype.collapseToStart = function () {
|
|
|
- return Range.collapseToStart(this);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new empty range using this range's start position.
|
|
|
- */
|
|
|
- Range.collapseToStart = function (range) {
|
|
|
- return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);
|
|
|
- };
|
|
|
- // ---
|
|
|
- Range.fromPositions = function (start, end) {
|
|
|
- if (end === void 0) { end = start; }
|
|
|
- return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a `Range` from an `IRange`.
|
|
|
- */
|
|
|
- Range.lift = function (range) {
|
|
|
- if (!range) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `obj` is an `IRange`.
|
|
|
- */
|
|
|
- Range.isIRange = function (obj) {
|
|
|
- return (obj
|
|
|
- && (typeof obj.startLineNumber === 'number')
|
|
|
- && (typeof obj.startColumn === 'number')
|
|
|
- && (typeof obj.endLineNumber === 'number')
|
|
|
- && (typeof obj.endColumn === 'number'));
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if the two ranges are touching in any way.
|
|
|
- */
|
|
|
- Range.areIntersectingOrTouching = function (a, b) {
|
|
|
- // Check if `a` is before `b`
|
|
|
- if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- // Check if `b` is before `a`
|
|
|
- if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- // These ranges must intersect
|
|
|
- return true;
|
|
|
- };
|
|
|
- /**
|
|
|
- * A function that compares ranges, useful for sorting ranges
|
|
|
- * It will first compare ranges on the startPosition and then on the endPosition
|
|
|
- */
|
|
|
- Range.compareRangesUsingStarts = function (a, b) {
|
|
|
- var aStartLineNumber = a.startLineNumber | 0;
|
|
|
- var bStartLineNumber = b.startLineNumber | 0;
|
|
|
- if (aStartLineNumber === bStartLineNumber) {
|
|
|
- var aStartColumn = a.startColumn | 0;
|
|
|
- var bStartColumn = b.startColumn | 0;
|
|
|
- if (aStartColumn === bStartColumn) {
|
|
|
- var aEndLineNumber = a.endLineNumber | 0;
|
|
|
- var bEndLineNumber = b.endLineNumber | 0;
|
|
|
- if (aEndLineNumber === bEndLineNumber) {
|
|
|
- var aEndColumn = a.endColumn | 0;
|
|
|
- var bEndColumn = b.endColumn | 0;
|
|
|
- return aEndColumn - bEndColumn;
|
|
|
- }
|
|
|
- return aEndLineNumber - bEndLineNumber;
|
|
|
- }
|
|
|
- return aStartColumn - bStartColumn;
|
|
|
- }
|
|
|
- return aStartLineNumber - bStartLineNumber;
|
|
|
- };
|
|
|
- /**
|
|
|
- * A function that compares ranges, useful for sorting ranges
|
|
|
- * It will first compare ranges on the endPosition and then on the startPosition
|
|
|
- */
|
|
|
- Range.compareRangesUsingEnds = function (a, b) {
|
|
|
- if (a.endLineNumber === b.endLineNumber) {
|
|
|
- if (a.endColumn === b.endColumn) {
|
|
|
- if (a.startLineNumber === b.startLineNumber) {
|
|
|
- return a.startColumn - b.startColumn;
|
|
|
- }
|
|
|
- return a.startLineNumber - b.startLineNumber;
|
|
|
- }
|
|
|
- return a.endColumn - b.endColumn;
|
|
|
- }
|
|
|
- return a.endLineNumber - b.endLineNumber;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if the range spans multiple lines.
|
|
|
- */
|
|
|
- Range.spansMultipleLines = function (range) {
|
|
|
- return range.endLineNumber > range.startLineNumber;
|
|
|
- };
|
|
|
- return Range;
|
|
|
- }());
|
|
|
- exports.Range = Range;
|
|
|
-});
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-define(__m[22/*vs/editor/common/core/selection*/], __M([1/*require*/,0/*exports*/,5/*vs/editor/common/core/range*/,3/*vs/editor/common/core/position*/]), function (require, exports, range_1, position_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * The direction of a selection.
|
|
|
- */
|
|
|
- var SelectionDirection;
|
|
|
- (function (SelectionDirection) {
|
|
|
- /**
|
|
|
- * The selection starts above where it ends.
|
|
|
- */
|
|
|
- SelectionDirection[SelectionDirection["LTR"] = 0] = "LTR";
|
|
|
- /**
|
|
|
- * The selection starts below where it ends.
|
|
|
- */
|
|
|
- SelectionDirection[SelectionDirection["RTL"] = 1] = "RTL";
|
|
|
- })(SelectionDirection = exports.SelectionDirection || (exports.SelectionDirection = {}));
|
|
|
- /**
|
|
|
- * A selection in the editor.
|
|
|
- * The selection is a range that has an orientation.
|
|
|
- */
|
|
|
- var Selection = (function (_super) {
|
|
|
- __extends(Selection, _super);
|
|
|
- function Selection(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {
|
|
|
- var _this = _super.call(this, selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) || this;
|
|
|
- _this.selectionStartLineNumber = selectionStartLineNumber;
|
|
|
- _this.selectionStartColumn = selectionStartColumn;
|
|
|
- _this.positionLineNumber = positionLineNumber;
|
|
|
- _this.positionColumn = positionColumn;
|
|
|
- return _this;
|
|
|
- }
|
|
|
- /**
|
|
|
- * Clone this selection.
|
|
|
- */
|
|
|
- Selection.prototype.clone = function () {
|
|
|
- return new Selection(this.selectionStartLineNumber, this.selectionStartColumn, this.positionLineNumber, this.positionColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Transform to a human-readable representation.
|
|
|
- */
|
|
|
- Selection.prototype.toString = function () {
|
|
|
- return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if equals other selection.
|
|
|
- */
|
|
|
- Selection.prototype.equalsSelection = function (other) {
|
|
|
- return (Selection.selectionsEqual(this, other));
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if the two selections are equal.
|
|
|
- */
|
|
|
- Selection.selectionsEqual = function (a, b) {
|
|
|
- return (a.selectionStartLineNumber === b.selectionStartLineNumber &&
|
|
|
- a.selectionStartColumn === b.selectionStartColumn &&
|
|
|
- a.positionLineNumber === b.positionLineNumber &&
|
|
|
- a.positionColumn === b.positionColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Get directions (LTR or RTL).
|
|
|
- */
|
|
|
- Selection.prototype.getDirection = function () {
|
|
|
- if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {
|
|
|
- return SelectionDirection.LTR;
|
|
|
- }
|
|
|
- return SelectionDirection.RTL;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new selection with a different `positionLineNumber` and `positionColumn`.
|
|
|
- */
|
|
|
- Selection.prototype.setEndPosition = function (endLineNumber, endColumn) {
|
|
|
- if (this.getDirection() === SelectionDirection.LTR) {
|
|
|
- return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
|
|
|
- }
|
|
|
- return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Get the position at `positionLineNumber` and `positionColumn`.
|
|
|
- */
|
|
|
- Selection.prototype.getPosition = function () {
|
|
|
- return new position_1.Position(this.positionLineNumber, this.positionColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.
|
|
|
- */
|
|
|
- Selection.prototype.setStartPosition = function (startLineNumber, startColumn) {
|
|
|
- if (this.getDirection() === SelectionDirection.LTR) {
|
|
|
- return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
|
|
|
- }
|
|
|
- return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);
|
|
|
- };
|
|
|
- // ----
|
|
|
- /**
|
|
|
- * Create a `Selection` from one or two positions
|
|
|
- */
|
|
|
- Selection.fromPositions = function (start, end) {
|
|
|
- if (end === void 0) { end = start; }
|
|
|
- return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create a `Selection` from an `ISelection`.
|
|
|
- */
|
|
|
- Selection.liftSelection = function (sel) {
|
|
|
- return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);
|
|
|
- };
|
|
|
- /**
|
|
|
- * `a` equals `b`.
|
|
|
- */
|
|
|
- Selection.selectionsArrEqual = function (a, b) {
|
|
|
- if (a && !b || !a && b) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- if (!a && !b) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- if (a.length !== b.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var i = 0, len = a.length; i < len; i++) {
|
|
|
- if (!this.selectionsEqual(a[i], b[i])) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- /**
|
|
|
- * Test if `obj` is an `ISelection`.
|
|
|
- */
|
|
|
- Selection.isISelection = function (obj) {
|
|
|
- return (obj
|
|
|
- && (typeof obj.selectionStartLineNumber === 'number')
|
|
|
- && (typeof obj.selectionStartColumn === 'number')
|
|
|
- && (typeof obj.positionLineNumber === 'number')
|
|
|
- && (typeof obj.positionColumn === 'number'));
|
|
|
- };
|
|
|
- /**
|
|
|
- * Create with a direction.
|
|
|
- */
|
|
|
- Selection.createWithDirection = function (startLineNumber, startColumn, endLineNumber, endColumn, direction) {
|
|
|
- if (direction === SelectionDirection.LTR) {
|
|
|
- return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);
|
|
|
- }
|
|
|
- return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);
|
|
|
- };
|
|
|
- return Selection;
|
|
|
- }(range_1.Range));
|
|
|
- exports.Selection = Selection;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[23/*vs/editor/common/core/token*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var Token = (function () {
|
|
|
- function Token(offset, type, language) {
|
|
|
- this.offset = offset | 0; // @perf
|
|
|
- this.type = type;
|
|
|
- this.language = language;
|
|
|
- }
|
|
|
- Token.prototype.toString = function () {
|
|
|
- return '(' + this.offset + ', ' + this.type + ')';
|
|
|
- };
|
|
|
- return Token;
|
|
|
- }());
|
|
|
- exports.Token = Token;
|
|
|
- var TokenizationResult = (function () {
|
|
|
- function TokenizationResult(tokens, endState) {
|
|
|
- this.tokens = tokens;
|
|
|
- this.endState = endState;
|
|
|
- }
|
|
|
- return TokenizationResult;
|
|
|
- }());
|
|
|
- exports.TokenizationResult = TokenizationResult;
|
|
|
- var TokenizationResult2 = (function () {
|
|
|
- function TokenizationResult2(tokens, endState) {
|
|
|
- this.tokens = tokens;
|
|
|
- this.endState = endState;
|
|
|
- }
|
|
|
- return TokenizationResult2;
|
|
|
- }());
|
|
|
- exports.TokenizationResult2 = TokenizationResult2;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[7/*vs/editor/common/core/uint*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var Uint8Matrix = (function () {
|
|
|
- function Uint8Matrix(rows, cols, defaultValue) {
|
|
|
- var data = new Uint8Array(rows * cols);
|
|
|
- for (var i = 0, len = rows * cols; i < len; i++) {
|
|
|
- data[i] = defaultValue;
|
|
|
- }
|
|
|
- this._data = data;
|
|
|
- this._rows = rows;
|
|
|
- this._cols = cols;
|
|
|
- }
|
|
|
- Uint8Matrix.prototype.get = function (row, col) {
|
|
|
- return this._data[row * this._cols + col];
|
|
|
- };
|
|
|
- Uint8Matrix.prototype.set = function (row, col, value) {
|
|
|
- this._data[row * this._cols + col] = value;
|
|
|
- };
|
|
|
- return Uint8Matrix;
|
|
|
- }());
|
|
|
- exports.Uint8Matrix = Uint8Matrix;
|
|
|
- var Constants;
|
|
|
- (function (Constants) {
|
|
|
- /**
|
|
|
- * MAX SMI (SMall Integer) as defined in v8.
|
|
|
- * one bit is lost for boxing/unboxing flag.
|
|
|
- * one bit is lost for sign flag.
|
|
|
- * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
|
|
|
- */
|
|
|
- Constants[Constants["MAX_SAFE_SMALL_INTEGER"] = 1073741824] = "MAX_SAFE_SMALL_INTEGER";
|
|
|
- /**
|
|
|
- * MIN SMI (SMall Integer) as defined in v8.
|
|
|
- * one bit is lost for boxing/unboxing flag.
|
|
|
- * one bit is lost for sign flag.
|
|
|
- * See https://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/#tagged-values
|
|
|
- */
|
|
|
- Constants[Constants["MIN_SAFE_SMALL_INTEGER"] = -1073741824] = "MIN_SAFE_SMALL_INTEGER";
|
|
|
- /**
|
|
|
- * Max unsigned integer that fits on 8 bits.
|
|
|
- */
|
|
|
- Constants[Constants["MAX_UINT_8"] = 255] = "MAX_UINT_8";
|
|
|
- /**
|
|
|
- * Max unsigned integer that fits on 16 bits.
|
|
|
- */
|
|
|
- Constants[Constants["MAX_UINT_16"] = 65535] = "MAX_UINT_16";
|
|
|
- /**
|
|
|
- * Max unsigned integer that fits on 32 bits.
|
|
|
- */
|
|
|
- Constants[Constants["MAX_UINT_32"] = 4294967295] = "MAX_UINT_32";
|
|
|
- })(Constants = exports.Constants || (exports.Constants = {}));
|
|
|
- function toUint8(v) {
|
|
|
- if (v < 0) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if (v > 255 /* MAX_UINT_8 */) {
|
|
|
- return 255 /* MAX_UINT_8 */;
|
|
|
- }
|
|
|
- return v | 0;
|
|
|
- }
|
|
|
- exports.toUint8 = toUint8;
|
|
|
- function toUint32(v) {
|
|
|
- if (v < 0) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- if (v > 4294967295 /* MAX_UINT_32 */) {
|
|
|
- return 4294967295 /* MAX_UINT_32 */;
|
|
|
- }
|
|
|
- return v | 0;
|
|
|
- }
|
|
|
- exports.toUint32 = toUint32;
|
|
|
- function toUint32Array(arr) {
|
|
|
- var len = arr.length;
|
|
|
- var r = new Uint32Array(len);
|
|
|
- for (var i = 0; i < len; i++) {
|
|
|
- r[i] = toUint32(arr[i]);
|
|
|
- }
|
|
|
- return r;
|
|
|
- }
|
|
|
- exports.toUint32Array = toUint32Array;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[25/*vs/editor/common/core/characterClassifier*/], __M([1/*require*/,0/*exports*/,7/*vs/editor/common/core/uint*/]), function (require, exports, uint_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * A fast character classifier that uses a compact array for ASCII values.
|
|
|
- */
|
|
|
- var CharacterClassifier = (function () {
|
|
|
- function CharacterClassifier(_defaultValue) {
|
|
|
- var defaultValue = uint_1.toUint8(_defaultValue);
|
|
|
- this._defaultValue = defaultValue;
|
|
|
- this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
|
|
|
- this._map = new Map();
|
|
|
- }
|
|
|
- CharacterClassifier._createAsciiMap = function (defaultValue) {
|
|
|
- var asciiMap = new Uint8Array(256);
|
|
|
- for (var i = 0; i < 256; i++) {
|
|
|
- asciiMap[i] = defaultValue;
|
|
|
- }
|
|
|
- return asciiMap;
|
|
|
- };
|
|
|
- CharacterClassifier.prototype.set = function (charCode, _value) {
|
|
|
- var value = uint_1.toUint8(_value);
|
|
|
- if (charCode >= 0 && charCode < 256) {
|
|
|
- this._asciiMap[charCode] = value;
|
|
|
- }
|
|
|
- else {
|
|
|
- this._map.set(charCode, value);
|
|
|
- }
|
|
|
- };
|
|
|
- CharacterClassifier.prototype.get = function (charCode) {
|
|
|
- if (charCode >= 0 && charCode < 256) {
|
|
|
- return this._asciiMap[charCode];
|
|
|
- }
|
|
|
- else {
|
|
|
- return (this._map.get(charCode) || this._defaultValue);
|
|
|
- }
|
|
|
- };
|
|
|
- return CharacterClassifier;
|
|
|
- }());
|
|
|
- exports.CharacterClassifier = CharacterClassifier;
|
|
|
- var Boolean;
|
|
|
- (function (Boolean) {
|
|
|
- Boolean[Boolean["False"] = 0] = "False";
|
|
|
- Boolean[Boolean["True"] = 1] = "True";
|
|
|
- })(Boolean || (Boolean = {}));
|
|
|
- var CharacterSet = (function () {
|
|
|
- function CharacterSet() {
|
|
|
- this._actual = new CharacterClassifier(0 /* False */);
|
|
|
- }
|
|
|
- CharacterSet.prototype.add = function (charCode) {
|
|
|
- this._actual.set(charCode, 1 /* True */);
|
|
|
- };
|
|
|
- CharacterSet.prototype.has = function (charCode) {
|
|
|
- return (this._actual.get(charCode) === 1 /* True */);
|
|
|
- };
|
|
|
- return CharacterSet;
|
|
|
- }());
|
|
|
- exports.CharacterSet = CharacterSet;
|
|
|
-});
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-define(__m[26/*vs/editor/common/diff/diffComputer*/], __M([1/*require*/,0/*exports*/,12/*vs/base/common/diff/diff*/,20/*vs/base/common/strings*/]), function (require, exports, diff_1, strings) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var MAXIMUM_RUN_TIME = 5000; // 5 seconds
|
|
|
- var MINIMUM_MATCHING_CHARACTER_LENGTH = 3;
|
|
|
- function computeDiff(originalSequence, modifiedSequence, continueProcessingPredicate) {
|
|
|
- var diffAlgo = new diff_1.LcsDiff(originalSequence, modifiedSequence, continueProcessingPredicate);
|
|
|
- return diffAlgo.ComputeDiff();
|
|
|
- }
|
|
|
- var MarkerSequence = (function () {
|
|
|
- function MarkerSequence(buffer, startMarkers, endMarkers) {
|
|
|
- this.buffer = buffer;
|
|
|
- this.startMarkers = startMarkers;
|
|
|
- this.endMarkers = endMarkers;
|
|
|
- }
|
|
|
- MarkerSequence.prototype.equals = function (other) {
|
|
|
- if (!(other instanceof MarkerSequence)) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- var otherMarkerSequence = other;
|
|
|
- if (this.getLength() !== otherMarkerSequence.getLength()) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- for (var i = 0, len = this.getLength(); i < len; i++) {
|
|
|
- var myElement = this.getElementHash(i);
|
|
|
- var otherElement = otherMarkerSequence.getElementHash(i);
|
|
|
- if (myElement !== otherElement) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getLength = function () {
|
|
|
- return this.startMarkers.length;
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getElementHash = function (i) {
|
|
|
- return this.buffer.substring(this.startMarkers[i].offset, this.endMarkers[i].offset);
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getStartLineNumber = function (i) {
|
|
|
- if (i === this.startMarkers.length) {
|
|
|
- // This is the special case where a change happened after the last marker
|
|
|
- return this.startMarkers[i - 1].lineNumber + 1;
|
|
|
- }
|
|
|
- return this.startMarkers[i].lineNumber;
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getStartColumn = function (i) {
|
|
|
- return this.startMarkers[i].column;
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getEndLineNumber = function (i) {
|
|
|
- return this.endMarkers[i].lineNumber;
|
|
|
- };
|
|
|
- MarkerSequence.prototype.getEndColumn = function (i) {
|
|
|
- return this.endMarkers[i].column;
|
|
|
- };
|
|
|
- return MarkerSequence;
|
|
|
- }());
|
|
|
- var LineMarkerSequence = (function (_super) {
|
|
|
- __extends(LineMarkerSequence, _super);
|
|
|
- function LineMarkerSequence(lines, shouldIgnoreTrimWhitespace) {
|
|
|
- var _this = this;
|
|
|
- var i, length, pos;
|
|
|
- var buffer = '';
|
|
|
- var startMarkers = [], endMarkers = [], startColumn, endColumn;
|
|
|
- for (pos = 0, i = 0, length = lines.length; i < length; i++) {
|
|
|
- buffer += lines[i];
|
|
|
- startColumn = 1;
|
|
|
- endColumn = lines[i].length + 1;
|
|
|
- if (shouldIgnoreTrimWhitespace) {
|
|
|
- startColumn = LineMarkerSequence._getFirstNonBlankColumn(lines[i], 1);
|
|
|
- endColumn = LineMarkerSequence._getLastNonBlankColumn(lines[i], 1);
|
|
|
- }
|
|
|
- startMarkers.push({
|
|
|
- offset: pos + startColumn - 1,
|
|
|
- lineNumber: i + 1,
|
|
|
- column: startColumn
|
|
|
- });
|
|
|
- endMarkers.push({
|
|
|
- offset: pos + endColumn - 1,
|
|
|
- lineNumber: i + 1,
|
|
|
- column: endColumn
|
|
|
- });
|
|
|
- pos += lines[i].length;
|
|
|
- }
|
|
|
- _this = _super.call(this, buffer, startMarkers, endMarkers) || this;
|
|
|
- return _this;
|
|
|
- }
|
|
|
- LineMarkerSequence._getFirstNonBlankColumn = function (txt, defaultValue) {
|
|
|
- var r = strings.firstNonWhitespaceIndex(txt);
|
|
|
- if (r === -1) {
|
|
|
- return defaultValue;
|
|
|
- }
|
|
|
- return r + 1;
|
|
|
- };
|
|
|
- LineMarkerSequence._getLastNonBlankColumn = function (txt, defaultValue) {
|
|
|
- var r = strings.lastNonWhitespaceIndex(txt);
|
|
|
- if (r === -1) {
|
|
|
- return defaultValue;
|
|
|
- }
|
|
|
- return r + 2;
|
|
|
- };
|
|
|
- LineMarkerSequence.prototype.getCharSequence = function (startIndex, endIndex) {
|
|
|
- var startMarkers = [], endMarkers = [], index, i, startMarker, endMarker;
|
|
|
- for (index = startIndex; index <= endIndex; index++) {
|
|
|
- startMarker = this.startMarkers[index];
|
|
|
- endMarker = this.endMarkers[index];
|
|
|
- for (i = startMarker.offset; i < endMarker.offset; i++) {
|
|
|
- startMarkers.push({
|
|
|
- offset: i,
|
|
|
- lineNumber: startMarker.lineNumber,
|
|
|
- column: startMarker.column + (i - startMarker.offset)
|
|
|
- });
|
|
|
- endMarkers.push({
|
|
|
- offset: i + 1,
|
|
|
- lineNumber: startMarker.lineNumber,
|
|
|
- column: startMarker.column + (i - startMarker.offset) + 1
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- return new MarkerSequence(this.buffer, startMarkers, endMarkers);
|
|
|
- };
|
|
|
- return LineMarkerSequence;
|
|
|
- }(MarkerSequence));
|
|
|
- var CharChange = (function () {
|
|
|
- function CharChange(diffChange, originalCharSequence, modifiedCharSequence) {
|
|
|
- if (diffChange.originalLength === 0) {
|
|
|
- this.originalStartLineNumber = 0;
|
|
|
- this.originalStartColumn = 0;
|
|
|
- this.originalEndLineNumber = 0;
|
|
|
- this.originalEndColumn = 0;
|
|
|
- }
|
|
|
- else {
|
|
|
- this.originalStartLineNumber = originalCharSequence.getStartLineNumber(diffChange.originalStart);
|
|
|
- this.originalStartColumn = originalCharSequence.getStartColumn(diffChange.originalStart);
|
|
|
- this.originalEndLineNumber = originalCharSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
|
|
|
- this.originalEndColumn = originalCharSequence.getEndColumn(diffChange.originalStart + diffChange.originalLength - 1);
|
|
|
- }
|
|
|
- if (diffChange.modifiedLength === 0) {
|
|
|
- this.modifiedStartLineNumber = 0;
|
|
|
- this.modifiedStartColumn = 0;
|
|
|
- this.modifiedEndLineNumber = 0;
|
|
|
- this.modifiedEndColumn = 0;
|
|
|
- }
|
|
|
- else {
|
|
|
- this.modifiedStartLineNumber = modifiedCharSequence.getStartLineNumber(diffChange.modifiedStart);
|
|
|
- this.modifiedStartColumn = modifiedCharSequence.getStartColumn(diffChange.modifiedStart);
|
|
|
- this.modifiedEndLineNumber = modifiedCharSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
|
|
|
- this.modifiedEndColumn = modifiedCharSequence.getEndColumn(diffChange.modifiedStart + diffChange.modifiedLength - 1);
|
|
|
- }
|
|
|
- }
|
|
|
- return CharChange;
|
|
|
- }());
|
|
|
- function postProcessCharChanges(rawChanges) {
|
|
|
- if (rawChanges.length <= 1) {
|
|
|
- return rawChanges;
|
|
|
- }
|
|
|
- var result = [rawChanges[0]];
|
|
|
- var i, len, originalMatchingLength, modifiedMatchingLength, matchingLength, prevChange = result[0], currChange;
|
|
|
- for (i = 1, len = rawChanges.length; i < len; i++) {
|
|
|
- currChange = rawChanges[i];
|
|
|
- originalMatchingLength = currChange.originalStart - (prevChange.originalStart + prevChange.originalLength);
|
|
|
- modifiedMatchingLength = currChange.modifiedStart - (prevChange.modifiedStart + prevChange.modifiedLength);
|
|
|
- // Both of the above should be equal, but the continueProcessingPredicate may prevent this from being true
|
|
|
- matchingLength = Math.min(originalMatchingLength, modifiedMatchingLength);
|
|
|
- if (matchingLength < MINIMUM_MATCHING_CHARACTER_LENGTH) {
|
|
|
- // Merge the current change into the previous one
|
|
|
- prevChange.originalLength = (currChange.originalStart + currChange.originalLength) - prevChange.originalStart;
|
|
|
- prevChange.modifiedLength = (currChange.modifiedStart + currChange.modifiedLength) - prevChange.modifiedStart;
|
|
|
- }
|
|
|
- else {
|
|
|
- // Add the current change
|
|
|
- result.push(currChange);
|
|
|
- prevChange = currChange;
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- }
|
|
|
- var LineChange = (function () {
|
|
|
- function LineChange(diffChange, originalLineSequence, modifiedLineSequence, continueProcessingPredicate, shouldPostProcessCharChanges) {
|
|
|
- if (diffChange.originalLength === 0) {
|
|
|
- this.originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart) - 1;
|
|
|
- this.originalEndLineNumber = 0;
|
|
|
- }
|
|
|
- else {
|
|
|
- this.originalStartLineNumber = originalLineSequence.getStartLineNumber(diffChange.originalStart);
|
|
|
- this.originalEndLineNumber = originalLineSequence.getEndLineNumber(diffChange.originalStart + diffChange.originalLength - 1);
|
|
|
- }
|
|
|
- if (diffChange.modifiedLength === 0) {
|
|
|
- this.modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart) - 1;
|
|
|
- this.modifiedEndLineNumber = 0;
|
|
|
- }
|
|
|
- else {
|
|
|
- this.modifiedStartLineNumber = modifiedLineSequence.getStartLineNumber(diffChange.modifiedStart);
|
|
|
- this.modifiedEndLineNumber = modifiedLineSequence.getEndLineNumber(diffChange.modifiedStart + diffChange.modifiedLength - 1);
|
|
|
- }
|
|
|
- if (diffChange.originalLength !== 0 && diffChange.modifiedLength !== 0 && continueProcessingPredicate()) {
|
|
|
- var originalCharSequence = originalLineSequence.getCharSequence(diffChange.originalStart, diffChange.originalStart + diffChange.originalLength - 1);
|
|
|
- var modifiedCharSequence = modifiedLineSequence.getCharSequence(diffChange.modifiedStart, diffChange.modifiedStart + diffChange.modifiedLength - 1);
|
|
|
- var rawChanges = computeDiff(originalCharSequence, modifiedCharSequence, continueProcessingPredicate);
|
|
|
- if (shouldPostProcessCharChanges) {
|
|
|
- rawChanges = postProcessCharChanges(rawChanges);
|
|
|
- }
|
|
|
- this.charChanges = [];
|
|
|
- for (var i = 0, length = rawChanges.length; i < length; i++) {
|
|
|
- this.charChanges.push(new CharChange(rawChanges[i], originalCharSequence, modifiedCharSequence));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- return LineChange;
|
|
|
- }());
|
|
|
- var DiffComputer = (function () {
|
|
|
- function DiffComputer(originalLines, modifiedLines, opts) {
|
|
|
- this.shouldPostProcessCharChanges = opts.shouldPostProcessCharChanges;
|
|
|
- this.shouldIgnoreTrimWhitespace = opts.shouldIgnoreTrimWhitespace;
|
|
|
- this.maximumRunTimeMs = MAXIMUM_RUN_TIME;
|
|
|
- this.original = new LineMarkerSequence(originalLines, this.shouldIgnoreTrimWhitespace);
|
|
|
- this.modified = new LineMarkerSequence(modifiedLines, this.shouldIgnoreTrimWhitespace);
|
|
|
- if (opts.shouldConsiderTrimWhitespaceInEmptyCase && this.shouldIgnoreTrimWhitespace && this.original.equals(this.modified)) {
|
|
|
- // Diff would be empty with `shouldIgnoreTrimWhitespace`
|
|
|
- this.shouldIgnoreTrimWhitespace = false;
|
|
|
- this.original = new LineMarkerSequence(originalLines, this.shouldIgnoreTrimWhitespace);
|
|
|
- this.modified = new LineMarkerSequence(modifiedLines, this.shouldIgnoreTrimWhitespace);
|
|
|
- }
|
|
|
- }
|
|
|
- DiffComputer.prototype.computeDiff = function () {
|
|
|
- if (this.original.getLength() === 1 && this.original.getElementHash(0).length === 0) {
|
|
|
- // empty original => fast path
|
|
|
- return [{
|
|
|
- originalStartLineNumber: 1,
|
|
|
- originalEndLineNumber: 1,
|
|
|
- modifiedStartLineNumber: 1,
|
|
|
- modifiedEndLineNumber: this.modified.getLength(),
|
|
|
- charChanges: [{
|
|
|
- modifiedEndColumn: 0,
|
|
|
- modifiedEndLineNumber: 0,
|
|
|
- modifiedStartColumn: 0,
|
|
|
- modifiedStartLineNumber: 0,
|
|
|
- originalEndColumn: 0,
|
|
|
- originalEndLineNumber: 0,
|
|
|
- originalStartColumn: 0,
|
|
|
- originalStartLineNumber: 0
|
|
|
- }]
|
|
|
- }];
|
|
|
- }
|
|
|
- if (this.modified.getLength() === 1 && this.modified.getElementHash(0).length === 0) {
|
|
|
- // empty modified => fast path
|
|
|
- return [{
|
|
|
- originalStartLineNumber: 1,
|
|
|
- originalEndLineNumber: this.original.getLength(),
|
|
|
- modifiedStartLineNumber: 1,
|
|
|
- modifiedEndLineNumber: 1,
|
|
|
- charChanges: [{
|
|
|
- modifiedEndColumn: 0,
|
|
|
- modifiedEndLineNumber: 0,
|
|
|
- modifiedStartColumn: 0,
|
|
|
- modifiedStartLineNumber: 0,
|
|
|
- originalEndColumn: 0,
|
|
|
- originalEndLineNumber: 0,
|
|
|
- originalStartColumn: 0,
|
|
|
- originalStartLineNumber: 0
|
|
|
- }]
|
|
|
- }];
|
|
|
- }
|
|
|
- this.computationStartTime = (new Date()).getTime();
|
|
|
- var rawChanges = computeDiff(this.original, this.modified, this._continueProcessingPredicate.bind(this));
|
|
|
- var lineChanges = [];
|
|
|
- for (var i = 0, length = rawChanges.length; i < length; i++) {
|
|
|
- lineChanges.push(new LineChange(rawChanges[i], this.original, this.modified, this._continueProcessingPredicate.bind(this), this.shouldPostProcessCharChanges));
|
|
|
- }
|
|
|
- return lineChanges;
|
|
|
- };
|
|
|
- DiffComputer.prototype._continueProcessingPredicate = function () {
|
|
|
- if (this.maximumRunTimeMs === 0) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- var now = (new Date()).getTime();
|
|
|
- return now - this.computationStartTime < this.maximumRunTimeMs;
|
|
|
- };
|
|
|
- return DiffComputer;
|
|
|
- }());
|
|
|
- exports.DiffComputer = DiffComputer;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[27/*vs/editor/common/model/wordHelper*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- exports.USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
|
|
|
- /**
|
|
|
- * Create a word definition regular expression based on default word separators.
|
|
|
- * Optionally provide allowed separators that should be included in words.
|
|
|
- *
|
|
|
- * The default would look like this:
|
|
|
- * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
|
|
|
- */
|
|
|
- function createWordRegExp(allowInWords) {
|
|
|
- if (allowInWords === void 0) { allowInWords = ''; }
|
|
|
- var usualSeparators = exports.USUAL_WORD_SEPARATORS;
|
|
|
- var source = '(-?\\d*\\.\\d\\w*)|([^';
|
|
|
- for (var i = 0; i < usualSeparators.length; i++) {
|
|
|
- if (allowInWords.indexOf(usualSeparators[i]) >= 0) {
|
|
|
- continue;
|
|
|
- }
|
|
|
- source += '\\' + usualSeparators[i];
|
|
|
- }
|
|
|
- source += '\\s]+)';
|
|
|
- return new RegExp(source, 'g');
|
|
|
- }
|
|
|
- // catches numbers (including floating numbers) in the first group, and alphanum in the second
|
|
|
- exports.DEFAULT_WORD_REGEXP = createWordRegExp();
|
|
|
- function ensureValidWordDefinition(wordDefinition) {
|
|
|
- var result = exports.DEFAULT_WORD_REGEXP;
|
|
|
- if (wordDefinition && (wordDefinition instanceof RegExp)) {
|
|
|
- if (!wordDefinition.global) {
|
|
|
- var flags = 'g';
|
|
|
- if (wordDefinition.ignoreCase) {
|
|
|
- flags += 'i';
|
|
|
- }
|
|
|
- if (wordDefinition.multiline) {
|
|
|
- flags += 'm';
|
|
|
- }
|
|
|
- result = new RegExp(wordDefinition.source, flags);
|
|
|
- }
|
|
|
- else {
|
|
|
- result = wordDefinition;
|
|
|
- }
|
|
|
- }
|
|
|
- result.lastIndex = 0;
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.ensureValidWordDefinition = ensureValidWordDefinition;
|
|
|
- function getWordAtPosFast(column, wordDefinition, text, textOffset) {
|
|
|
- // find whitespace enclosed text around column and match from there
|
|
|
- if (wordDefinition.test(' ')) {
|
|
|
- return getWordAtPosSlow(column, wordDefinition, text, textOffset);
|
|
|
- }
|
|
|
- var pos = column - 1 - textOffset;
|
|
|
- var start = text.lastIndexOf(' ', pos - 1) + 1;
|
|
|
- var end = text.indexOf(' ', pos);
|
|
|
- if (end === -1) {
|
|
|
- end = text.length;
|
|
|
- }
|
|
|
- wordDefinition.lastIndex = start;
|
|
|
- var match;
|
|
|
- while (match = wordDefinition.exec(text)) {
|
|
|
- if (match.index <= pos && wordDefinition.lastIndex >= pos) {
|
|
|
- return {
|
|
|
- word: match[0],
|
|
|
- startColumn: textOffset + 1 + match.index,
|
|
|
- endColumn: textOffset + 1 + wordDefinition.lastIndex
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- function getWordAtPosSlow(column, wordDefinition, text, textOffset) {
|
|
|
- // matches all words starting at the beginning
|
|
|
- // of the input until it finds a match that encloses
|
|
|
- // the desired column. slow but correct
|
|
|
- var pos = column - 1 - textOffset;
|
|
|
- wordDefinition.lastIndex = 0;
|
|
|
- var match;
|
|
|
- while (match = wordDefinition.exec(text)) {
|
|
|
- if (match.index > pos) {
|
|
|
- // |nW -> matched only after the pos
|
|
|
- return null;
|
|
|
- }
|
|
|
- else if (wordDefinition.lastIndex >= pos) {
|
|
|
- // W|W -> match encloses pos
|
|
|
- return {
|
|
|
- word: match[0],
|
|
|
- startColumn: textOffset + 1 + match.index,
|
|
|
- endColumn: textOffset + 1 + wordDefinition.lastIndex
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- }
|
|
|
- function getWordAtText(column, wordDefinition, text, textOffset) {
|
|
|
- var result = getWordAtPosFast(column, wordDefinition, text, textOffset);
|
|
|
- // both (getWordAtPosFast and getWordAtPosSlow) leave the wordDefinition-RegExp
|
|
|
- // in an undefined state and to not confuse other users of the wordDefinition
|
|
|
- // we reset the lastIndex
|
|
|
- wordDefinition.lastIndex = 0;
|
|
|
- return result;
|
|
|
- }
|
|
|
- exports.getWordAtText = getWordAtText;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[28/*vs/editor/common/modes/linkComputer*/], __M([1/*require*/,0/*exports*/,25/*vs/editor/common/core/characterClassifier*/,7/*vs/editor/common/core/uint*/]), function (require, exports, characterClassifier_1, uint_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var State;
|
|
|
- (function (State) {
|
|
|
- State[State["Invalid"] = 0] = "Invalid";
|
|
|
- State[State["Start"] = 1] = "Start";
|
|
|
- State[State["H"] = 2] = "H";
|
|
|
- State[State["HT"] = 3] = "HT";
|
|
|
- State[State["HTT"] = 4] = "HTT";
|
|
|
- State[State["HTTP"] = 5] = "HTTP";
|
|
|
- State[State["F"] = 6] = "F";
|
|
|
- State[State["FI"] = 7] = "FI";
|
|
|
- State[State["FIL"] = 8] = "FIL";
|
|
|
- State[State["BeforeColon"] = 9] = "BeforeColon";
|
|
|
- State[State["AfterColon"] = 10] = "AfterColon";
|
|
|
- State[State["AlmostThere"] = 11] = "AlmostThere";
|
|
|
- State[State["End"] = 12] = "End";
|
|
|
- State[State["Accept"] = 13] = "Accept";
|
|
|
- })(State || (State = {}));
|
|
|
- var StateMachine = (function () {
|
|
|
- function StateMachine(edges) {
|
|
|
- var maxCharCode = 0;
|
|
|
- var maxState = 0 /* Invalid */;
|
|
|
- for (var i = 0, len = edges.length; i < len; i++) {
|
|
|
- var _a = edges[i], from = _a[0], chCode = _a[1], to = _a[2];
|
|
|
- if (chCode > maxCharCode) {
|
|
|
- maxCharCode = chCode;
|
|
|
- }
|
|
|
- if (from > maxState) {
|
|
|
- maxState = from;
|
|
|
- }
|
|
|
- if (to > maxState) {
|
|
|
- maxState = to;
|
|
|
- }
|
|
|
- }
|
|
|
- maxCharCode++;
|
|
|
- maxState++;
|
|
|
- var states = new uint_1.Uint8Matrix(maxState, maxCharCode, 0 /* Invalid */);
|
|
|
- for (var i = 0, len = edges.length; i < len; i++) {
|
|
|
- var _b = edges[i], from = _b[0], chCode = _b[1], to = _b[2];
|
|
|
- states.set(from, chCode, to);
|
|
|
- }
|
|
|
- this._states = states;
|
|
|
- this._maxCharCode = maxCharCode;
|
|
|
- }
|
|
|
- StateMachine.prototype.nextState = function (currentState, chCode) {
|
|
|
- if (chCode < 0 || chCode >= this._maxCharCode) {
|
|
|
- return 0 /* Invalid */;
|
|
|
- }
|
|
|
- return this._states.get(currentState, chCode);
|
|
|
- };
|
|
|
- return StateMachine;
|
|
|
- }());
|
|
|
- // State machine for http:// or https:// or file://
|
|
|
- var _stateMachine = null;
|
|
|
- function getStateMachine() {
|
|
|
- if (_stateMachine === null) {
|
|
|
- _stateMachine = new StateMachine([
|
|
|
- [1 /* Start */, 104 /* h */, 2 /* H */],
|
|
|
- [1 /* Start */, 72 /* H */, 2 /* H */],
|
|
|
- [1 /* Start */, 102 /* f */, 6 /* F */],
|
|
|
- [1 /* Start */, 70 /* F */, 6 /* F */],
|
|
|
- [2 /* H */, 116 /* t */, 3 /* HT */],
|
|
|
- [2 /* H */, 84 /* T */, 3 /* HT */],
|
|
|
- [3 /* HT */, 116 /* t */, 4 /* HTT */],
|
|
|
- [3 /* HT */, 84 /* T */, 4 /* HTT */],
|
|
|
- [4 /* HTT */, 112 /* p */, 5 /* HTTP */],
|
|
|
- [4 /* HTT */, 80 /* P */, 5 /* HTTP */],
|
|
|
- [5 /* HTTP */, 115 /* s */, 9 /* BeforeColon */],
|
|
|
- [5 /* HTTP */, 83 /* S */, 9 /* BeforeColon */],
|
|
|
- [5 /* HTTP */, 58 /* Colon */, 10 /* AfterColon */],
|
|
|
- [6 /* F */, 105 /* i */, 7 /* FI */],
|
|
|
- [6 /* F */, 73 /* I */, 7 /* FI */],
|
|
|
- [7 /* FI */, 108 /* l */, 8 /* FIL */],
|
|
|
- [7 /* FI */, 76 /* L */, 8 /* FIL */],
|
|
|
- [8 /* FIL */, 101 /* e */, 9 /* BeforeColon */],
|
|
|
- [8 /* FIL */, 69 /* E */, 9 /* BeforeColon */],
|
|
|
- [9 /* BeforeColon */, 58 /* Colon */, 10 /* AfterColon */],
|
|
|
- [10 /* AfterColon */, 47 /* Slash */, 11 /* AlmostThere */],
|
|
|
- [11 /* AlmostThere */, 47 /* Slash */, 12 /* End */],
|
|
|
- ]);
|
|
|
- }
|
|
|
- return _stateMachine;
|
|
|
- }
|
|
|
- var CharacterClass;
|
|
|
- (function (CharacterClass) {
|
|
|
- CharacterClass[CharacterClass["None"] = 0] = "None";
|
|
|
- CharacterClass[CharacterClass["ForceTermination"] = 1] = "ForceTermination";
|
|
|
- CharacterClass[CharacterClass["CannotEndIn"] = 2] = "CannotEndIn";
|
|
|
- })(CharacterClass || (CharacterClass = {}));
|
|
|
- var _classifier = null;
|
|
|
- function getClassifier() {
|
|
|
- if (_classifier === null) {
|
|
|
- _classifier = new characterClassifier_1.CharacterClassifier(0 /* None */);
|
|
|
- var FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；？！＠＃＄％＆＊‘“〈《「『【〔（［｛｢｣｝］）〕】』」》〉”’｀～…';
|
|
|
- for (var i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
|
|
|
- _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* ForceTermination */);
|
|
|
- }
|
|
|
- var CANNOT_END_WITH_CHARACTERS = '.,;';
|
|
|
- for (var i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {
|
|
|
- _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CannotEndIn */);
|
|
|
- }
|
|
|
- }
|
|
|
- return _classifier;
|
|
|
- }
|
|
|
- var LinkComputer = (function () {
|
|
|
- function LinkComputer() {
|
|
|
- }
|
|
|
- LinkComputer._createLink = function (classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {
|
|
|
- // Do not allow to end link in certain characters...
|
|
|
- var lastIncludedCharIndex = linkEndIndex - 1;
|
|
|
- do {
|
|
|
- var chCode = line.charCodeAt(lastIncludedCharIndex);
|
|
|
- var chClass = classifier.get(chCode);
|
|
|
- if (chClass !== 2 /* CannotEndIn */) {
|
|
|
- break;
|
|
|
- }
|
|
|
- lastIncludedCharIndex--;
|
|
|
- } while (lastIncludedCharIndex > linkBeginIndex);
|
|
|
- return {
|
|
|
- range: {
|
|
|
- startLineNumber: lineNumber,
|
|
|
- startColumn: linkBeginIndex + 1,
|
|
|
- endLineNumber: lineNumber,
|
|
|
- endColumn: lastIncludedCharIndex + 2
|
|
|
- },
|
|
|
- url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)
|
|
|
- };
|
|
|
- };
|
|
|
- LinkComputer.computeLinks = function (model) {
|
|
|
- var stateMachine = getStateMachine();
|
|
|
- var classifier = getClassifier();
|
|
|
- var result = [];
|
|
|
- for (var i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {
|
|
|
- var line = model.getLineContent(i);
|
|
|
- var len = line.length;
|
|
|
- var j = 0;
|
|
|
- var linkBeginIndex = 0;
|
|
|
- var linkBeginChCode = 0;
|
|
|
- var state = 1 /* Start */;
|
|
|
- var hasOpenParens = false;
|
|
|
- var hasOpenSquareBracket = false;
|
|
|
- var hasOpenCurlyBracket = false;
|
|
|
- while (j < len) {
|
|
|
- var resetStateMachine = false;
|
|
|
- var chCode = line.charCodeAt(j);
|
|
|
- if (state === 13 /* Accept */) {
|
|
|
- var chClass = void 0;
|
|
|
- switch (chCode) {
|
|
|
- case 40 /* OpenParen */:
|
|
|
- hasOpenParens = true;
|
|
|
- chClass = 0 /* None */;
|
|
|
- break;
|
|
|
- case 41 /* CloseParen */:
|
|
|
- chClass = (hasOpenParens ? 0 /* None */ : 1 /* ForceTermination */);
|
|
|
- break;
|
|
|
- case 91 /* OpenSquareBracket */:
|
|
|
- hasOpenSquareBracket = true;
|
|
|
- chClass = 0 /* None */;
|
|
|
- break;
|
|
|
- case 93 /* CloseSquareBracket */:
|
|
|
- chClass = (hasOpenSquareBracket ? 0 /* None */ : 1 /* ForceTermination */);
|
|
|
- break;
|
|
|
- case 123 /* OpenCurlyBrace */:
|
|
|
- hasOpenCurlyBracket = true;
|
|
|
- chClass = 0 /* None */;
|
|
|
- break;
|
|
|
- case 125 /* CloseCurlyBrace */:
|
|
|
- chClass = (hasOpenCurlyBracket ? 0 /* None */ : 1 /* ForceTermination */);
|
|
|
- break;
|
|
|
- /* The following three rules make it that ' or " or ` are allowed inside links if the link began with a different one */
|
|
|
- case 39 /* SingleQuote */:
|
|
|
- chClass = (linkBeginChCode === 34 /* DoubleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;
|
|
|
- break;
|
|
|
- case 34 /* DoubleQuote */:
|
|
|
- chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 96 /* BackTick */) ? 0 /* None */ : 1 /* ForceTermination */;
|
|
|
- break;
|
|
|
- case 96 /* BackTick */:
|
|
|
- chClass = (linkBeginChCode === 39 /* SingleQuote */ || linkBeginChCode === 34 /* DoubleQuote */) ? 0 /* None */ : 1 /* ForceTermination */;
|
|
|
- break;
|
|
|
- default:
|
|
|
- chClass = classifier.get(chCode);
|
|
|
- }
|
|
|
- // Check if character terminates link
|
|
|
- if (chClass === 1 /* ForceTermination */) {
|
|
|
- result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));
|
|
|
- resetStateMachine = true;
|
|
|
- }
|
|
|
- }
|
|
|
- else if (state === 12 /* End */) {
|
|
|
- var chClass = classifier.get(chCode);
|
|
|
- // Check if character terminates link
|
|
|
- if (chClass === 1 /* ForceTermination */) {
|
|
|
- resetStateMachine = true;
|
|
|
- }
|
|
|
- else {
|
|
|
- state = 13 /* Accept */;
|
|
|
- }
|
|
|
- }
|
|
|
- else {
|
|
|
- state = stateMachine.nextState(state, chCode);
|
|
|
- if (state === 0 /* Invalid */) {
|
|
|
- resetStateMachine = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (resetStateMachine) {
|
|
|
- state = 1 /* Start */;
|
|
|
- hasOpenParens = false;
|
|
|
- hasOpenSquareBracket = false;
|
|
|
- hasOpenCurlyBracket = false;
|
|
|
- // Record where the link started
|
|
|
- linkBeginIndex = j + 1;
|
|
|
- linkBeginChCode = chCode;
|
|
|
- }
|
|
|
- j++;
|
|
|
- }
|
|
|
- if (state === 13 /* Accept */) {
|
|
|
- result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));
|
|
|
- }
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- return LinkComputer;
|
|
|
- }());
|
|
|
- /**
|
|
|
- * Returns an array of all links contains in the provided
|
|
|
- * document. *Note* that this operation is computational
|
|
|
- * expensive and should not run in the UI thread.
|
|
|
- */
|
|
|
- function computeLinks(model) {
|
|
|
- if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {
|
|
|
- // Unknown caller!
|
|
|
- return [];
|
|
|
- }
|
|
|
- return LinkComputer.computeLinks(model);
|
|
|
- }
|
|
|
- exports.computeLinks = computeLinks;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[29/*vs/editor/common/modes/supports/inplaceReplaceSupport*/], __M([1/*require*/,0/*exports*/]), function (require, exports) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var BasicInplaceReplace = (function () {
|
|
|
- function BasicInplaceReplace() {
|
|
|
- this._defaultValueSet = [
|
|
|
- ['true', 'false'],
|
|
|
- ['True', 'False'],
|
|
|
- ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],
|
|
|
- ['public', 'protected', 'private'],
|
|
|
- ];
|
|
|
- }
|
|
|
- BasicInplaceReplace.prototype.navigateValueSet = function (range1, text1, range2, text2, up) {
|
|
|
- if (range1 && text1) {
|
|
|
- var result = this.doNavigateValueSet(text1, up);
|
|
|
- if (result) {
|
|
|
- return {
|
|
|
- range: range1,
|
|
|
- value: result
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- if (range2 && text2) {
|
|
|
- var result = this.doNavigateValueSet(text2, up);
|
|
|
- if (result) {
|
|
|
- return {
|
|
|
- range: range2,
|
|
|
- value: result
|
|
|
- };
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- BasicInplaceReplace.prototype.doNavigateValueSet = function (text, up) {
|
|
|
- var numberResult = this.numberReplace(text, up);
|
|
|
- if (numberResult !== null) {
|
|
|
- return numberResult;
|
|
|
- }
|
|
|
- return this.textReplace(text, up);
|
|
|
- };
|
|
|
- BasicInplaceReplace.prototype.numberReplace = function (value, up) {
|
|
|
- var precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1)), n1 = Number(value), n2 = parseFloat(value);
|
|
|
- if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {
|
|
|
- if (n1 === 0 && !up) {
|
|
|
- return null; // don't do negative
|
|
|
- // } else if(n1 === 9 && up) {
|
|
|
- // return null; // don't insert 10 into a number
|
|
|
- }
|
|
|
- else {
|
|
|
- n1 = Math.floor(n1 * precision);
|
|
|
- n1 += up ? precision : -precision;
|
|
|
- return String(n1 / precision);
|
|
|
- }
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- BasicInplaceReplace.prototype.textReplace = function (value, up) {
|
|
|
- return this.valueSetsReplace(this._defaultValueSet, value, up);
|
|
|
- };
|
|
|
- BasicInplaceReplace.prototype.valueSetsReplace = function (valueSets, value, up) {
|
|
|
- var result = null;
|
|
|
- for (var i = 0, len = valueSets.length; result === null && i < len; i++) {
|
|
|
- result = this.valueSetReplace(valueSets[i], value, up);
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- BasicInplaceReplace.prototype.valueSetReplace = function (valueSet, value, up) {
|
|
|
- var idx = valueSet.indexOf(value);
|
|
|
- if (idx >= 0) {
|
|
|
- idx += up ? +1 : -1;
|
|
|
- if (idx < 0) {
|
|
|
- idx = valueSet.length - 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- idx %= valueSet.length;
|
|
|
- }
|
|
|
- return valueSet[idx];
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- return BasicInplaceReplace;
|
|
|
- }());
|
|
|
- BasicInplaceReplace.INSTANCE = new BasicInplaceReplace();
|
|
|
- exports.BasicInplaceReplace = BasicInplaceReplace;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[30/*vs/editor/common/standalone/standaloneBase*/], __M([1/*require*/,0/*exports*/,9/*vs/base/common/event*/,21/*vs/base/common/keyCodes*/,3/*vs/editor/common/core/position*/,5/*vs/editor/common/core/range*/,22/*vs/editor/common/core/selection*/,2/*vs/base/common/winjs.base*/,13/*vs/base/common/cancellation*/,23/*vs/editor/common/core/token*/,6/*vs/base/common/uri*/]), function (require, exports, event_1, keyCodes_1, position_1, range_1, selection_1, winjs_base_1, cancellation_1, token_1, uri_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- // --------------------------------------------
|
|
|
- // This is repeated here so it can be exported
|
|
|
- // because TS inlines const enums
|
|
|
- // --------------------------------------------
|
|
|
- var Severity;
|
|
|
- (function (Severity) {
|
|
|
- Severity[Severity["Ignore"] = 0] = "Ignore";
|
|
|
- Severity[Severity["Info"] = 1] = "Info";
|
|
|
- Severity[Severity["Warning"] = 2] = "Warning";
|
|
|
- Severity[Severity["Error"] = 3] = "Error";
|
|
|
- })(Severity = exports.Severity || (exports.Severity = {}));
|
|
|
- // --------------------------------------------
|
|
|
- // This is repeated here so it can be exported
|
|
|
- // because TS inlines const enums
|
|
|
- // --------------------------------------------
|
|
|
- var KeyMod = (function () {
|
|
|
- function KeyMod() {
|
|
|
- }
|
|
|
- KeyMod.chord = function (firstPart, secondPart) {
|
|
|
- return keyCodes_1.KeyChord(firstPart, secondPart);
|
|
|
- };
|
|
|
- return KeyMod;
|
|
|
- }());
|
|
|
- KeyMod.CtrlCmd = 2048 /* CtrlCmd */;
|
|
|
- KeyMod.Shift = 1024 /* Shift */;
|
|
|
- KeyMod.Alt = 512 /* Alt */;
|
|
|
- KeyMod.WinCtrl = 256 /* WinCtrl */;
|
|
|
- exports.KeyMod = KeyMod;
|
|
|
- // --------------------------------------------
|
|
|
- // This is repeated here so it can be exported
|
|
|
- // because TS inlines const enums
|
|
|
- // --------------------------------------------
|
|
|
- /**
|
|
|
- * Virtual Key Codes, the value does not hold any inherent meaning.
|
|
|
- * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
|
|
|
- * But these are "more general", as they should work across browsers & OS`s.
|
|
|
- */
|
|
|
- var KeyCode;
|
|
|
- (function (KeyCode) {
|
|
|
- /**
|
|
|
- * Placed first to cover the 0 value of the enum.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["Unknown"] = 0] = "Unknown";
|
|
|
- KeyCode[KeyCode["Backspace"] = 1] = "Backspace";
|
|
|
- KeyCode[KeyCode["Tab"] = 2] = "Tab";
|
|
|
- KeyCode[KeyCode["Enter"] = 3] = "Enter";
|
|
|
- KeyCode[KeyCode["Shift"] = 4] = "Shift";
|
|
|
- KeyCode[KeyCode["Ctrl"] = 5] = "Ctrl";
|
|
|
- KeyCode[KeyCode["Alt"] = 6] = "Alt";
|
|
|
- KeyCode[KeyCode["PauseBreak"] = 7] = "PauseBreak";
|
|
|
- KeyCode[KeyCode["CapsLock"] = 8] = "CapsLock";
|
|
|
- KeyCode[KeyCode["Escape"] = 9] = "Escape";
|
|
|
- KeyCode[KeyCode["Space"] = 10] = "Space";
|
|
|
- KeyCode[KeyCode["PageUp"] = 11] = "PageUp";
|
|
|
- KeyCode[KeyCode["PageDown"] = 12] = "PageDown";
|
|
|
- KeyCode[KeyCode["End"] = 13] = "End";
|
|
|
- KeyCode[KeyCode["Home"] = 14] = "Home";
|
|
|
- KeyCode[KeyCode["LeftArrow"] = 15] = "LeftArrow";
|
|
|
- KeyCode[KeyCode["UpArrow"] = 16] = "UpArrow";
|
|
|
- KeyCode[KeyCode["RightArrow"] = 17] = "RightArrow";
|
|
|
- KeyCode[KeyCode["DownArrow"] = 18] = "DownArrow";
|
|
|
- KeyCode[KeyCode["Insert"] = 19] = "Insert";
|
|
|
- KeyCode[KeyCode["Delete"] = 20] = "Delete";
|
|
|
- KeyCode[KeyCode["KEY_0"] = 21] = "KEY_0";
|
|
|
- KeyCode[KeyCode["KEY_1"] = 22] = "KEY_1";
|
|
|
- KeyCode[KeyCode["KEY_2"] = 23] = "KEY_2";
|
|
|
- KeyCode[KeyCode["KEY_3"] = 24] = "KEY_3";
|
|
|
- KeyCode[KeyCode["KEY_4"] = 25] = "KEY_4";
|
|
|
- KeyCode[KeyCode["KEY_5"] = 26] = "KEY_5";
|
|
|
- KeyCode[KeyCode["KEY_6"] = 27] = "KEY_6";
|
|
|
- KeyCode[KeyCode["KEY_7"] = 28] = "KEY_7";
|
|
|
- KeyCode[KeyCode["KEY_8"] = 29] = "KEY_8";
|
|
|
- KeyCode[KeyCode["KEY_9"] = 30] = "KEY_9";
|
|
|
- KeyCode[KeyCode["KEY_A"] = 31] = "KEY_A";
|
|
|
- KeyCode[KeyCode["KEY_B"] = 32] = "KEY_B";
|
|
|
- KeyCode[KeyCode["KEY_C"] = 33] = "KEY_C";
|
|
|
- KeyCode[KeyCode["KEY_D"] = 34] = "KEY_D";
|
|
|
- KeyCode[KeyCode["KEY_E"] = 35] = "KEY_E";
|
|
|
- KeyCode[KeyCode["KEY_F"] = 36] = "KEY_F";
|
|
|
- KeyCode[KeyCode["KEY_G"] = 37] = "KEY_G";
|
|
|
- KeyCode[KeyCode["KEY_H"] = 38] = "KEY_H";
|
|
|
- KeyCode[KeyCode["KEY_I"] = 39] = "KEY_I";
|
|
|
- KeyCode[KeyCode["KEY_J"] = 40] = "KEY_J";
|
|
|
- KeyCode[KeyCode["KEY_K"] = 41] = "KEY_K";
|
|
|
- KeyCode[KeyCode["KEY_L"] = 42] = "KEY_L";
|
|
|
- KeyCode[KeyCode["KEY_M"] = 43] = "KEY_M";
|
|
|
- KeyCode[KeyCode["KEY_N"] = 44] = "KEY_N";
|
|
|
- KeyCode[KeyCode["KEY_O"] = 45] = "KEY_O";
|
|
|
- KeyCode[KeyCode["KEY_P"] = 46] = "KEY_P";
|
|
|
- KeyCode[KeyCode["KEY_Q"] = 47] = "KEY_Q";
|
|
|
- KeyCode[KeyCode["KEY_R"] = 48] = "KEY_R";
|
|
|
- KeyCode[KeyCode["KEY_S"] = 49] = "KEY_S";
|
|
|
- KeyCode[KeyCode["KEY_T"] = 50] = "KEY_T";
|
|
|
- KeyCode[KeyCode["KEY_U"] = 51] = "KEY_U";
|
|
|
- KeyCode[KeyCode["KEY_V"] = 52] = "KEY_V";
|
|
|
- KeyCode[KeyCode["KEY_W"] = 53] = "KEY_W";
|
|
|
- KeyCode[KeyCode["KEY_X"] = 54] = "KEY_X";
|
|
|
- KeyCode[KeyCode["KEY_Y"] = 55] = "KEY_Y";
|
|
|
- KeyCode[KeyCode["KEY_Z"] = 56] = "KEY_Z";
|
|
|
- KeyCode[KeyCode["Meta"] = 57] = "Meta";
|
|
|
- KeyCode[KeyCode["ContextMenu"] = 58] = "ContextMenu";
|
|
|
- KeyCode[KeyCode["F1"] = 59] = "F1";
|
|
|
- KeyCode[KeyCode["F2"] = 60] = "F2";
|
|
|
- KeyCode[KeyCode["F3"] = 61] = "F3";
|
|
|
- KeyCode[KeyCode["F4"] = 62] = "F4";
|
|
|
- KeyCode[KeyCode["F5"] = 63] = "F5";
|
|
|
- KeyCode[KeyCode["F6"] = 64] = "F6";
|
|
|
- KeyCode[KeyCode["F7"] = 65] = "F7";
|
|
|
- KeyCode[KeyCode["F8"] = 66] = "F8";
|
|
|
- KeyCode[KeyCode["F9"] = 67] = "F9";
|
|
|
- KeyCode[KeyCode["F10"] = 68] = "F10";
|
|
|
- KeyCode[KeyCode["F11"] = 69] = "F11";
|
|
|
- KeyCode[KeyCode["F12"] = 70] = "F12";
|
|
|
- KeyCode[KeyCode["F13"] = 71] = "F13";
|
|
|
- KeyCode[KeyCode["F14"] = 72] = "F14";
|
|
|
- KeyCode[KeyCode["F15"] = 73] = "F15";
|
|
|
- KeyCode[KeyCode["F16"] = 74] = "F16";
|
|
|
- KeyCode[KeyCode["F17"] = 75] = "F17";
|
|
|
- KeyCode[KeyCode["F18"] = 76] = "F18";
|
|
|
- KeyCode[KeyCode["F19"] = 77] = "F19";
|
|
|
- KeyCode[KeyCode["NumLock"] = 78] = "NumLock";
|
|
|
- KeyCode[KeyCode["ScrollLock"] = 79] = "ScrollLock";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ';:' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_SEMICOLON"] = 80] = "US_SEMICOLON";
|
|
|
- /**
|
|
|
- * For any country/region, the '+' key
|
|
|
- * For the US standard keyboard, the '=+' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_EQUAL"] = 81] = "US_EQUAL";
|
|
|
- /**
|
|
|
- * For any country/region, the ',' key
|
|
|
- * For the US standard keyboard, the ',<' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_COMMA"] = 82] = "US_COMMA";
|
|
|
- /**
|
|
|
- * For any country/region, the '-' key
|
|
|
- * For the US standard keyboard, the '-_' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_MINUS"] = 83] = "US_MINUS";
|
|
|
- /**
|
|
|
- * For any country/region, the '.' key
|
|
|
- * For the US standard keyboard, the '.>' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_DOT"] = 84] = "US_DOT";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '/?' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_SLASH"] = 85] = "US_SLASH";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '`~' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_BACKTICK"] = 86] = "US_BACKTICK";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '[{' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_OPEN_SQUARE_BRACKET"] = 87] = "US_OPEN_SQUARE_BRACKET";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the '\|' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_BACKSLASH"] = 88] = "US_BACKSLASH";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ']}' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_CLOSE_SQUARE_BRACKET"] = 89] = "US_CLOSE_SQUARE_BRACKET";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- * For the US standard keyboard, the ''"' key
|
|
|
- */
|
|
|
- KeyCode[KeyCode["US_QUOTE"] = 90] = "US_QUOTE";
|
|
|
- /**
|
|
|
- * Used for miscellaneous characters; it can vary by keyboard.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["OEM_8"] = 91] = "OEM_8";
|
|
|
- /**
|
|
|
- * Either the angle bracket key or the backslash key on the RT 102-key keyboard.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["OEM_102"] = 92] = "OEM_102";
|
|
|
- KeyCode[KeyCode["NUMPAD_0"] = 93] = "NUMPAD_0";
|
|
|
- KeyCode[KeyCode["NUMPAD_1"] = 94] = "NUMPAD_1";
|
|
|
- KeyCode[KeyCode["NUMPAD_2"] = 95] = "NUMPAD_2";
|
|
|
- KeyCode[KeyCode["NUMPAD_3"] = 96] = "NUMPAD_3";
|
|
|
- KeyCode[KeyCode["NUMPAD_4"] = 97] = "NUMPAD_4";
|
|
|
- KeyCode[KeyCode["NUMPAD_5"] = 98] = "NUMPAD_5";
|
|
|
- KeyCode[KeyCode["NUMPAD_6"] = 99] = "NUMPAD_6";
|
|
|
- KeyCode[KeyCode["NUMPAD_7"] = 100] = "NUMPAD_7";
|
|
|
- KeyCode[KeyCode["NUMPAD_8"] = 101] = "NUMPAD_8";
|
|
|
- KeyCode[KeyCode["NUMPAD_9"] = 102] = "NUMPAD_9";
|
|
|
- KeyCode[KeyCode["NUMPAD_MULTIPLY"] = 103] = "NUMPAD_MULTIPLY";
|
|
|
- KeyCode[KeyCode["NUMPAD_ADD"] = 104] = "NUMPAD_ADD";
|
|
|
- KeyCode[KeyCode["NUMPAD_SEPARATOR"] = 105] = "NUMPAD_SEPARATOR";
|
|
|
- KeyCode[KeyCode["NUMPAD_SUBTRACT"] = 106] = "NUMPAD_SUBTRACT";
|
|
|
- KeyCode[KeyCode["NUMPAD_DECIMAL"] = 107] = "NUMPAD_DECIMAL";
|
|
|
- KeyCode[KeyCode["NUMPAD_DIVIDE"] = 108] = "NUMPAD_DIVIDE";
|
|
|
- /**
|
|
|
- * Cover all key codes when IME is processing input.
|
|
|
- */
|
|
|
- KeyCode[KeyCode["KEY_IN_COMPOSITION"] = 109] = "KEY_IN_COMPOSITION";
|
|
|
- KeyCode[KeyCode["ABNT_C1"] = 110] = "ABNT_C1";
|
|
|
- KeyCode[KeyCode["ABNT_C2"] = 111] = "ABNT_C2";
|
|
|
- /**
|
|
|
- * Placed last to cover the length of the enum.
|
|
|
- * Please do not depend on this value!
|
|
|
- */
|
|
|
- KeyCode[KeyCode["MAX_VALUE"] = 112] = "MAX_VALUE";
|
|
|
- })(KeyCode = exports.KeyCode || (exports.KeyCode = {}));
|
|
|
- function createMonacoBaseAPI() {
|
|
|
- return {
|
|
|
- editor: undefined,
|
|
|
- languages: undefined,
|
|
|
- CancellationTokenSource: cancellation_1.CancellationTokenSource,
|
|
|
- Emitter: event_1.Emitter,
|
|
|
- KeyCode: KeyCode,
|
|
|
- KeyMod: KeyMod,
|
|
|
- Position: position_1.Position,
|
|
|
- Range: range_1.Range,
|
|
|
- Selection: selection_1.Selection,
|
|
|
- SelectionDirection: selection_1.SelectionDirection,
|
|
|
- Severity: Severity,
|
|
|
- Promise: winjs_base_1.TPromise,
|
|
|
- Uri: uri_1.default,
|
|
|
- Token: token_1.Token
|
|
|
- };
|
|
|
- }
|
|
|
- exports.createMonacoBaseAPI = createMonacoBaseAPI;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[19/*vs/editor/common/viewModel/prefixSumComputer*/], __M([1/*require*/,0/*exports*/,7/*vs/editor/common/core/uint*/]), function (require, exports, uint_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var PrefixSumIndexOfResult = (function () {
|
|
|
- function PrefixSumIndexOfResult(index, remainder) {
|
|
|
- this.index = index;
|
|
|
- this.remainder = remainder;
|
|
|
- }
|
|
|
- return PrefixSumIndexOfResult;
|
|
|
- }());
|
|
|
- exports.PrefixSumIndexOfResult = PrefixSumIndexOfResult;
|
|
|
- var PrefixSumComputer = (function () {
|
|
|
- function PrefixSumComputer(values) {
|
|
|
- this.values = values;
|
|
|
- this.prefixSum = new Uint32Array(values.length);
|
|
|
- this.prefixSumValidIndex = new Int32Array(1);
|
|
|
- this.prefixSumValidIndex[0] = -1;
|
|
|
- }
|
|
|
- PrefixSumComputer.prototype.getCount = function () {
|
|
|
- return this.values.length;
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.insertValues = function (insertIndex, insertValues) {
|
|
|
- insertIndex = uint_1.toUint32(insertIndex);
|
|
|
- var oldValues = this.values;
|
|
|
- var oldPrefixSum = this.prefixSum;
|
|
|
- var insertValuesLen = insertValues.length;
|
|
|
- if (insertValuesLen === 0) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- this.values = new Uint32Array(oldValues.length + insertValuesLen);
|
|
|
- this.values.set(oldValues.subarray(0, insertIndex), 0);
|
|
|
- this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);
|
|
|
- this.values.set(insertValues, insertIndex);
|
|
|
- if (insertIndex - 1 < this.prefixSumValidIndex[0]) {
|
|
|
- this.prefixSumValidIndex[0] = insertIndex - 1;
|
|
|
- }
|
|
|
- this.prefixSum = new Uint32Array(this.values.length);
|
|
|
- if (this.prefixSumValidIndex[0] >= 0) {
|
|
|
- this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.changeValue = function (index, value) {
|
|
|
- index = uint_1.toUint32(index);
|
|
|
- value = uint_1.toUint32(value);
|
|
|
- if (this.values[index] === value) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- this.values[index] = value;
|
|
|
- if (index - 1 < this.prefixSumValidIndex[0]) {
|
|
|
- this.prefixSumValidIndex[0] = index - 1;
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.removeValues = function (startIndex, cnt) {
|
|
|
- startIndex = uint_1.toUint32(startIndex);
|
|
|
- cnt = uint_1.toUint32(cnt);
|
|
|
- var oldValues = this.values;
|
|
|
- var oldPrefixSum = this.prefixSum;
|
|
|
- if (startIndex >= oldValues.length) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- var maxCnt = oldValues.length - startIndex;
|
|
|
- if (cnt >= maxCnt) {
|
|
|
- cnt = maxCnt;
|
|
|
- }
|
|
|
- if (cnt === 0) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- this.values = new Uint32Array(oldValues.length - cnt);
|
|
|
- this.values.set(oldValues.subarray(0, startIndex), 0);
|
|
|
- this.values.set(oldValues.subarray(startIndex + cnt), startIndex);
|
|
|
- this.prefixSum = new Uint32Array(this.values.length);
|
|
|
- if (startIndex - 1 < this.prefixSumValidIndex[0]) {
|
|
|
- this.prefixSumValidIndex[0] = startIndex - 1;
|
|
|
- }
|
|
|
- if (this.prefixSumValidIndex[0] >= 0) {
|
|
|
- this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.getTotalValue = function () {
|
|
|
- if (this.values.length === 0) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- return this._getAccumulatedValue(this.values.length - 1);
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.getAccumulatedValue = function (index) {
|
|
|
- if (index < 0) {
|
|
|
- return 0;
|
|
|
- }
|
|
|
- index = uint_1.toUint32(index);
|
|
|
- return this._getAccumulatedValue(index);
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype._getAccumulatedValue = function (index) {
|
|
|
- if (index <= this.prefixSumValidIndex[0]) {
|
|
|
- return this.prefixSum[index];
|
|
|
- }
|
|
|
- var startIndex = this.prefixSumValidIndex[0] + 1;
|
|
|
- if (startIndex === 0) {
|
|
|
- this.prefixSum[0] = this.values[0];
|
|
|
- startIndex++;
|
|
|
- }
|
|
|
- if (index >= this.values.length) {
|
|
|
- index = this.values.length - 1;
|
|
|
- }
|
|
|
- for (var i = startIndex; i <= index; i++) {
|
|
|
- this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];
|
|
|
- }
|
|
|
- this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);
|
|
|
- return this.prefixSum[index];
|
|
|
- };
|
|
|
- PrefixSumComputer.prototype.getIndexOf = function (accumulatedValue) {
|
|
|
- accumulatedValue = Math.floor(accumulatedValue); //@perf
|
|
|
- // Compute all sums (to get a fully valid prefixSum)
|
|
|
- this.getTotalValue();
|
|
|
- var low = 0;
|
|
|
- var high = this.values.length - 1;
|
|
|
- var mid;
|
|
|
- var midStop;
|
|
|
- var midStart;
|
|
|
- while (low <= high) {
|
|
|
- mid = low + ((high - low) / 2) | 0;
|
|
|
- midStop = this.prefixSum[mid];
|
|
|
- midStart = midStop - this.values[mid];
|
|
|
- if (accumulatedValue < midStart) {
|
|
|
- high = mid - 1;
|
|
|
- }
|
|
|
- else if (accumulatedValue >= midStop) {
|
|
|
- low = mid + 1;
|
|
|
- }
|
|
|
- else {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return new PrefixSumIndexOfResult(mid, accumulatedValue - midStart);
|
|
|
- };
|
|
|
- return PrefixSumComputer;
|
|
|
- }());
|
|
|
- exports.PrefixSumComputer = PrefixSumComputer;
|
|
|
- var PrefixSumComputerWithCache = (function () {
|
|
|
- function PrefixSumComputerWithCache(values) {
|
|
|
- this._cacheAccumulatedValueStart = 0;
|
|
|
- this._cache = null;
|
|
|
- this._actual = new PrefixSumComputer(values);
|
|
|
- this._bustCache();
|
|
|
- }
|
|
|
- PrefixSumComputerWithCache.prototype._bustCache = function () {
|
|
|
- this._cacheAccumulatedValueStart = 0;
|
|
|
- this._cache = null;
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.getCount = function () {
|
|
|
- return this._actual.getCount();
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.insertValues = function (insertIndex, insertValues) {
|
|
|
- if (this._actual.insertValues(insertIndex, insertValues)) {
|
|
|
- this._bustCache();
|
|
|
- }
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.changeValue = function (index, value) {
|
|
|
- if (this._actual.changeValue(index, value)) {
|
|
|
- this._bustCache();
|
|
|
- }
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.removeValues = function (startIndex, cnt) {
|
|
|
- if (this._actual.removeValues(startIndex, cnt)) {
|
|
|
- this._bustCache();
|
|
|
- }
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.getTotalValue = function () {
|
|
|
- return this._actual.getTotalValue();
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.getAccumulatedValue = function (index) {
|
|
|
- return this._actual.getAccumulatedValue(index);
|
|
|
- };
|
|
|
- PrefixSumComputerWithCache.prototype.getIndexOf = function (accumulatedValue) {
|
|
|
- accumulatedValue = Math.floor(accumulatedValue); //@perf
|
|
|
- if (this._cache !== null) {
|
|
|
- var cacheIndex = accumulatedValue - this._cacheAccumulatedValueStart;
|
|
|
- if (cacheIndex >= 0 && cacheIndex < this._cache.length) {
|
|
|
- // Cache hit!
|
|
|
- return this._cache[cacheIndex];
|
|
|
- }
|
|
|
- }
|
|
|
- // Cache miss!
|
|
|
- return this._actual.getIndexOf(accumulatedValue);
|
|
|
- };
|
|
|
- /**
|
|
|
- * Gives a hint that a lot of requests are about to come in for these accumulated values.
|
|
|
- */
|
|
|
- PrefixSumComputerWithCache.prototype.warmUpCache = function (accumulatedValueStart, accumulatedValueEnd) {
|
|
|
- var newCache = [];
|
|
|
- for (var accumulatedValue = accumulatedValueStart; accumulatedValue <= accumulatedValueEnd; accumulatedValue++) {
|
|
|
- newCache[accumulatedValue - accumulatedValueStart] = this.getIndexOf(accumulatedValue);
|
|
|
- }
|
|
|
- this._cache = newCache;
|
|
|
- this._cacheAccumulatedValueStart = accumulatedValueStart;
|
|
|
- };
|
|
|
- return PrefixSumComputerWithCache;
|
|
|
- }());
|
|
|
- exports.PrefixSumComputerWithCache = PrefixSumComputerWithCache;
|
|
|
-});
|
|
|
-
|
|
|
-define(__m[24/*vs/editor/common/model/mirrorModel*/], __M([1/*require*/,0/*exports*/,19/*vs/editor/common/viewModel/prefixSumComputer*/]), function (require, exports, prefixSumComputer_1) {
|
|
|
- /*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- var MirrorModel = (function () {
|
|
|
- function MirrorModel(uri, lines, eol, versionId) {
|
|
|
- this._uri = uri;
|
|
|
- this._lines = lines;
|
|
|
- this._eol = eol;
|
|
|
- this._versionId = versionId;
|
|
|
- }
|
|
|
- MirrorModel.prototype.dispose = function () {
|
|
|
- this._lines.length = 0;
|
|
|
- };
|
|
|
- Object.defineProperty(MirrorModel.prototype, "version", {
|
|
|
- get: function () {
|
|
|
- return this._versionId;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- MirrorModel.prototype.getText = function () {
|
|
|
- return this._lines.join(this._eol);
|
|
|
- };
|
|
|
- MirrorModel.prototype.onEvents = function (e) {
|
|
|
- if (e.eol && e.eol !== this._eol) {
|
|
|
- this._eol = e.eol;
|
|
|
- this._lineStarts = null;
|
|
|
- }
|
|
|
- // Update my lines
|
|
|
- var changes = e.changes;
|
|
|
- for (var i = 0, len = changes.length; i < len; i++) {
|
|
|
- var change = changes[i];
|
|
|
- this._acceptDeleteRange(change.range);
|
|
|
- this._acceptInsertText({
|
|
|
- lineNumber: change.range.startLineNumber,
|
|
|
- column: change.range.startColumn
|
|
|
- }, change.text);
|
|
|
- }
|
|
|
- this._versionId = e.versionId;
|
|
|
- };
|
|
|
- MirrorModel.prototype._ensureLineStarts = function () {
|
|
|
- if (!this._lineStarts) {
|
|
|
- var eolLength = this._eol.length;
|
|
|
- var linesLength = this._lines.length;
|
|
|
- var lineStartValues = new Uint32Array(linesLength);
|
|
|
- for (var i = 0; i < linesLength; i++) {
|
|
|
- lineStartValues[i] = this._lines[i].length + eolLength;
|
|
|
- }
|
|
|
- this._lineStarts = new prefixSumComputer_1.PrefixSumComputer(lineStartValues);
|
|
|
- }
|
|
|
- };
|
|
|
- /**
|
|
|
- * All changes to a line's text go through this method
|
|
|
- */
|
|
|
- MirrorModel.prototype._setLineText = function (lineIndex, newValue) {
|
|
|
- this._lines[lineIndex] = newValue;
|
|
|
- if (this._lineStarts) {
|
|
|
- // update prefix sum
|
|
|
- this._lineStarts.changeValue(lineIndex, this._lines[lineIndex].length + this._eol.length);
|
|
|
- }
|
|
|
- };
|
|
|
- MirrorModel.prototype._acceptDeleteRange = function (range) {
|
|
|
- if (range.startLineNumber === range.endLineNumber) {
|
|
|
- if (range.startColumn === range.endColumn) {
|
|
|
- // Nothing to delete
|
|
|
- return;
|
|
|
- }
|
|
|
- // Delete text on the affected line
|
|
|
- this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
|
|
|
- + this._lines[range.startLineNumber - 1].substring(range.endColumn - 1));
|
|
|
- return;
|
|
|
- }
|
|
|
- // Take remaining text on last line and append it to remaining text on first line
|
|
|
- this._setLineText(range.startLineNumber - 1, this._lines[range.startLineNumber - 1].substring(0, range.startColumn - 1)
|
|
|
- + this._lines[range.endLineNumber - 1].substring(range.endColumn - 1));
|
|
|
- // Delete middle lines
|
|
|
- this._lines.splice(range.startLineNumber, range.endLineNumber - range.startLineNumber);
|
|
|
- if (this._lineStarts) {
|
|
|
- // update prefix sum
|
|
|
- this._lineStarts.removeValues(range.startLineNumber, range.endLineNumber - range.startLineNumber);
|
|
|
- }
|
|
|
- };
|
|
|
- MirrorModel.prototype._acceptInsertText = function (position, insertText) {
|
|
|
- if (insertText.length === 0) {
|
|
|
- // Nothing to insert
|
|
|
- return;
|
|
|
- }
|
|
|
- var insertLines = insertText.split(/\r\n|\r|\n/);
|
|
|
- if (insertLines.length === 1) {
|
|
|
- // Inserting text on one line
|
|
|
- this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
|
|
|
- + insertLines[0]
|
|
|
- + this._lines[position.lineNumber - 1].substring(position.column - 1));
|
|
|
- return;
|
|
|
- }
|
|
|
- // Append overflowing text from first line to the end of text to insert
|
|
|
- insertLines[insertLines.length - 1] += this._lines[position.lineNumber - 1].substring(position.column - 1);
|
|
|
- // Delete overflowing text from first line and insert text on first line
|
|
|
- this._setLineText(position.lineNumber - 1, this._lines[position.lineNumber - 1].substring(0, position.column - 1)
|
|
|
- + insertLines[0]);
|
|
|
- // Insert new lines & store lengths
|
|
|
- var newLengths = new Uint32Array(insertLines.length - 1);
|
|
|
- for (var i = 1; i < insertLines.length; i++) {
|
|
|
- this._lines.splice(position.lineNumber + i - 1, 0, insertLines[i]);
|
|
|
- newLengths[i - 1] = insertLines[i].length + this._eol.length;
|
|
|
- }
|
|
|
- if (this._lineStarts) {
|
|
|
- // update prefix sum
|
|
|
- this._lineStarts.insertValues(position.lineNumber, newLengths);
|
|
|
- }
|
|
|
- };
|
|
|
- return MirrorModel;
|
|
|
- }());
|
|
|
- exports.MirrorModel = MirrorModel;
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-define(__m[33/*vs/editor/common/services/editorSimpleWorker*/], __M([1/*require*/,0/*exports*/,6/*vs/base/common/uri*/,2/*vs/base/common/winjs.base*/,5/*vs/editor/common/core/range*/,26/*vs/editor/common/diff/diffComputer*/,12/*vs/base/common/diff/diff*/,3/*vs/editor/common/core/position*/,24/*vs/editor/common/model/mirrorModel*/,28/*vs/editor/common/modes/linkComputer*/,29/*vs/editor/common/modes/supports/inplaceReplaceSupport*/,27/*vs/editor/common/model/wordHelper*/,30/*vs/editor/common/standalone/standaloneBase*/]), function (require, exports, uri_1, winjs_base_1, range_1, diffComputer_1, diff_1, position_1, mirrorModel_1, linkComputer_1, inplaceReplaceSupport_1, wordHelper_1, standaloneBase_1) {
|
|
|
- 'use strict';
|
|
|
- Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
- /**
|
|
|
- * @internal
|
|
|
- */
|
|
|
- var MirrorModel = (function (_super) {
|
|
|
- __extends(MirrorModel, _super);
|
|
|
- function MirrorModel() {
|
|
|
- return _super !== null && _super.apply(this, arguments) || this;
|
|
|
- }
|
|
|
- Object.defineProperty(MirrorModel.prototype, "uri", {
|
|
|
- get: function () {
|
|
|
- return this._uri;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(MirrorModel.prototype, "version", {
|
|
|
- get: function () {
|
|
|
- return this._versionId;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- Object.defineProperty(MirrorModel.prototype, "eol", {
|
|
|
- get: function () {
|
|
|
- return this._eol;
|
|
|
- },
|
|
|
- enumerable: true,
|
|
|
- configurable: true
|
|
|
- });
|
|
|
- MirrorModel.prototype.getValue = function () {
|
|
|
- return this.getText();
|
|
|
- };
|
|
|
- MirrorModel.prototype.getLinesContent = function () {
|
|
|
- return this._lines.slice(0);
|
|
|
- };
|
|
|
- MirrorModel.prototype.getLineCount = function () {
|
|
|
- return this._lines.length;
|
|
|
- };
|
|
|
- MirrorModel.prototype.getLineContent = function (lineNumber) {
|
|
|
- return this._lines[lineNumber - 1];
|
|
|
- };
|
|
|
- MirrorModel.prototype.getWordAtPosition = function (position, wordDefinition) {
|
|
|
- var wordAtText = wordHelper_1.getWordAtText(position.column, wordHelper_1.ensureValidWordDefinition(wordDefinition), this._lines[position.lineNumber - 1], 0);
|
|
|
- if (wordAtText) {
|
|
|
- return new range_1.Range(position.lineNumber, wordAtText.startColumn, position.lineNumber, wordAtText.endColumn);
|
|
|
- }
|
|
|
- return null;
|
|
|
- };
|
|
|
- MirrorModel.prototype.getWordUntilPosition = function (position, wordDefinition) {
|
|
|
- var wordAtPosition = this.getWordAtPosition(position, wordDefinition);
|
|
|
- if (!wordAtPosition) {
|
|
|
- return {
|
|
|
- word: '',
|
|
|
- startColumn: position.column,
|
|
|
- endColumn: position.column
|
|
|
- };
|
|
|
- }
|
|
|
- return {
|
|
|
- word: this._lines[position.lineNumber - 1].substring(wordAtPosition.startColumn - 1, position.column - 1),
|
|
|
- startColumn: wordAtPosition.startColumn,
|
|
|
- endColumn: position.column
|
|
|
- };
|
|
|
- };
|
|
|
- MirrorModel.prototype._getAllWords = function (wordDefinition) {
|
|
|
- var _this = this;
|
|
|
- var result = [];
|
|
|
- this._lines.forEach(function (line) {
|
|
|
- _this._wordenize(line, wordDefinition).forEach(function (info) {
|
|
|
- result.push(line.substring(info.start, info.end));
|
|
|
- });
|
|
|
- });
|
|
|
- return result;
|
|
|
- };
|
|
|
- MirrorModel.prototype.getAllUniqueWords = function (wordDefinition, skipWordOnce) {
|
|
|
- var foundSkipWord = false;
|
|
|
- var uniqueWords = Object.create(null);
|
|
|
- return this._getAllWords(wordDefinition).filter(function (word) {
|
|
|
- if (skipWordOnce && !foundSkipWord && skipWordOnce === word) {
|
|
|
- foundSkipWord = true;
|
|
|
- return false;
|
|
|
- }
|
|
|
- else if (uniqueWords[word]) {
|
|
|
- return false;
|
|
|
- }
|
|
|
- else {
|
|
|
- uniqueWords[word] = true;
|
|
|
- return true;
|
|
|
- }
|
|
|
- });
|
|
|
- };
|
|
|
- MirrorModel.prototype._wordenize = function (content, wordDefinition) {
|
|
|
- var result = [];
|
|
|
- var match;
|
|
|
- wordDefinition.lastIndex = 0; // reset lastIndex just to be sure
|
|
|
- while (match = wordDefinition.exec(content)) {
|
|
|
- if (match[0].length === 0) {
|
|
|
- // it did match the empty string
|
|
|
- break;
|
|
|
- }
|
|
|
- result.push({ start: match.index, end: match.index + match[0].length });
|
|
|
- }
|
|
|
- return result;
|
|
|
- };
|
|
|
- MirrorModel.prototype.getValueInRange = function (range) {
|
|
|
- range = this._validateRange(range);
|
|
|
- if (range.startLineNumber === range.endLineNumber) {
|
|
|
- return this._lines[range.startLineNumber - 1].substring(range.startColumn - 1, range.endColumn - 1);
|
|
|
- }
|
|
|
- var lineEnding = this._eol, startLineIndex = range.startLineNumber - 1, endLineIndex = range.endLineNumber - 1, resultLines = [];
|
|
|
- resultLines.push(this._lines[startLineIndex].substring(range.startColumn - 1));
|
|
|
- for (var i = startLineIndex + 1; i < endLineIndex; i++) {
|
|
|
- resultLines.push(this._lines[i]);
|
|
|
- }
|
|
|
- resultLines.push(this._lines[endLineIndex].substring(0, range.endColumn - 1));
|
|
|
- return resultLines.join(lineEnding);
|
|
|
- };
|
|
|
- MirrorModel.prototype.offsetAt = function (position) {
|
|
|
- position = this._validatePosition(position);
|
|
|
- this._ensureLineStarts();
|
|
|
- return this._lineStarts.getAccumulatedValue(position.lineNumber - 2) + (position.column - 1);
|
|
|
- };
|
|
|
- MirrorModel.prototype.positionAt = function (offset) {
|
|
|
- offset = Math.floor(offset);
|
|
|
- offset = Math.max(0, offset);
|
|
|
- this._ensureLineStarts();
|
|
|
- var out = this._lineStarts.getIndexOf(offset);
|
|
|
- var lineLength = this._lines[out.index].length;
|
|
|
- // Ensure we return a valid position
|
|
|
- return {
|
|
|
- lineNumber: 1 + out.index,
|
|
|
- column: 1 + Math.min(out.remainder, lineLength)
|
|
|
- };
|
|
|
- };
|
|
|
- MirrorModel.prototype._validateRange = function (range) {
|
|
|
- var start = this._validatePosition({ lineNumber: range.startLineNumber, column: range.startColumn });
|
|
|
- var end = this._validatePosition({ lineNumber: range.endLineNumber, column: range.endColumn });
|
|
|
- if (start.lineNumber !== range.startLineNumber
|
|
|
- || start.column !== range.startColumn
|
|
|
- || end.lineNumber !== range.endLineNumber
|
|
|
- || end.column !== range.endColumn) {
|
|
|
- return {
|
|
|
- startLineNumber: start.lineNumber,
|
|
|
- startColumn: start.column,
|
|
|
- endLineNumber: end.lineNumber,
|
|
|
- endColumn: end.column
|
|
|
- };
|
|
|
- }
|
|
|
- return range;
|
|
|
- };
|
|
|
- MirrorModel.prototype._validatePosition = function (position) {
|
|
|
- if (!position_1.Position.isIPosition(position)) {
|
|
|
- throw new Error('bad position');
|
|
|
- }
|
|
|
- var lineNumber = position.lineNumber, column = position.column;
|
|
|
- var hasChanged = false;
|
|
|
- if (lineNumber < 1) {
|
|
|
- lineNumber = 1;
|
|
|
- column = 1;
|
|
|
- hasChanged = true;
|
|
|
- }
|
|
|
- else if (lineNumber > this._lines.length) {
|
|
|
- lineNumber = this._lines.length;
|
|
|
- column = this._lines[lineNumber - 1].length + 1;
|
|
|
- hasChanged = true;
|
|
|
- }
|
|
|
- else {
|
|
|
- var maxCharacter = this._lines[lineNumber - 1].length + 1;
|
|
|
- if (column < 1) {
|
|
|
- column = 1;
|
|
|
- hasChanged = true;
|
|
|
- }
|
|
|
- else if (column > maxCharacter) {
|
|
|
- column = maxCharacter;
|
|
|
- hasChanged = true;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!hasChanged) {
|
|
|
- return position;
|
|
|
- }
|
|
|
- else {
|
|
|
- return { lineNumber: lineNumber, column: column };
|
|
|
- }
|
|
|
- };
|
|
|
- return MirrorModel;
|
|
|
- }(mirrorModel_1.MirrorModel));
|
|
|
- /**
|
|
|
- * @internal
|
|
|
- */
|
|
|
- var BaseEditorSimpleWorker = (function () {
|
|
|
- function BaseEditorSimpleWorker() {
|
|
|
- this._foreignModule = null;
|
|
|
- }
|
|
|
- // ---- BEGIN diff --------------------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker.prototype.computeDiff = function (originalUrl, modifiedUrl, ignoreTrimWhitespace) {
|
|
|
- var original = this._getModel(originalUrl);
|
|
|
- var modified = this._getModel(modifiedUrl);
|
|
|
- if (!original || !modified) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var originalLines = original.getLinesContent();
|
|
|
- var modifiedLines = modified.getLinesContent();
|
|
|
- var diffComputer = new diffComputer_1.DiffComputer(originalLines, modifiedLines, {
|
|
|
- shouldPostProcessCharChanges: true,
|
|
|
- shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
|
|
|
- shouldConsiderTrimWhitespaceInEmptyCase: true
|
|
|
- });
|
|
|
- return winjs_base_1.TPromise.as(diffComputer.computeDiff());
|
|
|
- };
|
|
|
- BaseEditorSimpleWorker.prototype.computeDirtyDiff = function (originalUrl, modifiedUrl, ignoreTrimWhitespace) {
|
|
|
- var original = this._getModel(originalUrl);
|
|
|
- var modified = this._getModel(modifiedUrl);
|
|
|
- if (!original || !modified) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var originalLines = original.getLinesContent();
|
|
|
- var modifiedLines = modified.getLinesContent();
|
|
|
- var diffComputer = new diffComputer_1.DiffComputer(originalLines, modifiedLines, {
|
|
|
- shouldPostProcessCharChanges: false,
|
|
|
- shouldIgnoreTrimWhitespace: ignoreTrimWhitespace,
|
|
|
- shouldConsiderTrimWhitespaceInEmptyCase: false
|
|
|
- });
|
|
|
- return winjs_base_1.TPromise.as(diffComputer.computeDiff());
|
|
|
- };
|
|
|
- BaseEditorSimpleWorker.prototype.computeMoreMinimalEdits = function (modelUrl, edits, ranges) {
|
|
|
- var model = this._getModel(modelUrl);
|
|
|
- if (!model) {
|
|
|
- return winjs_base_1.TPromise.as(edits);
|
|
|
- }
|
|
|
- var result = [];
|
|
|
- var lastEol;
|
|
|
- for (var _i = 0, edits_1 = edits; _i < edits_1.length; _i++) {
|
|
|
- var _a = edits_1[_i], range = _a.range, text = _a.text, eol = _a.eol;
|
|
|
- if (typeof eol === 'number') {
|
|
|
- lastEol = eol;
|
|
|
- }
|
|
|
- if (!range) {
|
|
|
- // eol-change only
|
|
|
- continue;
|
|
|
- }
|
|
|
- var original = model.getValueInRange(range);
|
|
|
- text = text.replace(/\r\n|\n|\r/g, model.eol);
|
|
|
- if (original === text) {
|
|
|
- // noop
|
|
|
- continue;
|
|
|
- }
|
|
|
- // make sure diff won't take too long
|
|
|
- if (Math.max(text.length, original.length) > BaseEditorSimpleWorker._diffLimit) {
|
|
|
- result.push({ range: range, text: text });
|
|
|
- continue;
|
|
|
- }
|
|
|
- // compute diff between original and edit.text
|
|
|
- var changes = diff_1.stringDiff(original, text);
|
|
|
- var editOffset = model.offsetAt(range_1.Range.lift(range).getStartPosition());
|
|
|
- for (var _b = 0, changes_1 = changes; _b < changes_1.length; _b++) {
|
|
|
- var change = changes_1[_b];
|
|
|
- var start = model.positionAt(editOffset + change.originalStart);
|
|
|
- var end = model.positionAt(editOffset + change.originalStart + change.originalLength);
|
|
|
- var newEdit = {
|
|
|
- text: text.substr(change.modifiedStart, change.modifiedLength),
|
|
|
- range: { startLineNumber: start.lineNumber, startColumn: start.column, endLineNumber: end.lineNumber, endColumn: end.column }
|
|
|
- };
|
|
|
- if (model.getValueInRange(newEdit.range) !== newEdit.text) {
|
|
|
- result.push(newEdit);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- if (typeof lastEol === 'number') {
|
|
|
- result.push({ eol: lastEol, text: undefined, range: undefined });
|
|
|
- }
|
|
|
- return winjs_base_1.TPromise.as(result);
|
|
|
- };
|
|
|
- // ---- END minimal edits ---------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker.prototype.computeLinks = function (modelUrl) {
|
|
|
- var model = this._getModel(modelUrl);
|
|
|
- if (!model) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- return winjs_base_1.TPromise.as(linkComputer_1.computeLinks(model));
|
|
|
- };
|
|
|
- // ---- BEGIN suggest --------------------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker.prototype.textualSuggest = function (modelUrl, position, wordDef, wordDefFlags) {
|
|
|
- var model = this._getModel(modelUrl);
|
|
|
- if (model) {
|
|
|
- var suggestions = [];
|
|
|
- var wordDefRegExp = new RegExp(wordDef, wordDefFlags);
|
|
|
- var currentWord = model.getWordUntilPosition(position, wordDefRegExp).word;
|
|
|
- for (var _i = 0, _a = model.getAllUniqueWords(wordDefRegExp); _i < _a.length; _i++) {
|
|
|
- var word = _a[_i];
|
|
|
- if (word !== currentWord && isNaN(Number(word))) {
|
|
|
- suggestions.push({
|
|
|
- type: 'text',
|
|
|
- label: word,
|
|
|
- insertText: word,
|
|
|
- noAutoAccept: true,
|
|
|
- overwriteBefore: currentWord.length
|
|
|
- });
|
|
|
- }
|
|
|
- }
|
|
|
- return winjs_base_1.TPromise.as({ suggestions: suggestions });
|
|
|
- }
|
|
|
- return undefined;
|
|
|
- };
|
|
|
- // ---- END suggest --------------------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker.prototype.navigateValueSet = function (modelUrl, range, up, wordDef, wordDefFlags) {
|
|
|
- var model = this._getModel(modelUrl);
|
|
|
- if (!model) {
|
|
|
- return null;
|
|
|
- }
|
|
|
- var wordDefRegExp = new RegExp(wordDef, wordDefFlags);
|
|
|
- if (range.startColumn === range.endColumn) {
|
|
|
- range = {
|
|
|
- startLineNumber: range.startLineNumber,
|
|
|
- startColumn: range.startColumn,
|
|
|
- endLineNumber: range.endLineNumber,
|
|
|
- endColumn: range.endColumn + 1
|
|
|
- };
|
|
|
- }
|
|
|
- var selectionText = model.getValueInRange(range);
|
|
|
- var wordRange = model.getWordAtPosition({ lineNumber: range.startLineNumber, column: range.startColumn }, wordDefRegExp);
|
|
|
- var word = null;
|
|
|
- if (wordRange !== null) {
|
|
|
- word = model.getValueInRange(wordRange);
|
|
|
- }
|
|
|
- var result = inplaceReplaceSupport_1.BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
|
|
|
- return winjs_base_1.TPromise.as(result);
|
|
|
- };
|
|
|
- // ---- BEGIN foreign module support --------------------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker.prototype.loadForeignModule = function (moduleId, createData) {
|
|
|
- var _this = this;
|
|
|
- return new winjs_base_1.TPromise(function (c, e) {
|
|
|
- // Use the global require to be sure to get the global config
|
|
|
- self.require([moduleId], function (foreignModule) {
|
|
|
- var ctx = {
|
|
|
- getMirrorModels: function () {
|
|
|
- return _this._getModels();
|
|
|
- }
|
|
|
- };
|
|
|
- _this._foreignModule = foreignModule.create(ctx, createData);
|
|
|
- var methods = [];
|
|
|
- for (var prop in _this._foreignModule) {
|
|
|
- if (typeof _this._foreignModule[prop] === 'function') {
|
|
|
- methods.push(prop);
|
|
|
- }
|
|
|
- }
|
|
|
- c(methods);
|
|
|
- }, e);
|
|
|
- });
|
|
|
- };
|
|
|
- // foreign method request
|
|
|
- BaseEditorSimpleWorker.prototype.fmr = function (method, args) {
|
|
|
- if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
|
|
|
- return winjs_base_1.TPromise.wrapError(new Error('Missing requestHandler or method: ' + method));
|
|
|
- }
|
|
|
- try {
|
|
|
- return winjs_base_1.TPromise.as(this._foreignModule[method].apply(this._foreignModule, args));
|
|
|
- }
|
|
|
- catch (e) {
|
|
|
- return winjs_base_1.TPromise.wrapError(e);
|
|
|
- }
|
|
|
- };
|
|
|
- return BaseEditorSimpleWorker;
|
|
|
- }());
|
|
|
- // ---- END diff --------------------------------------------------------------------------
|
|
|
- // ---- BEGIN minimal edits ---------------------------------------------------------------
|
|
|
- BaseEditorSimpleWorker._diffLimit = 10000;
|
|
|
- exports.BaseEditorSimpleWorker = BaseEditorSimpleWorker;
|
|
|
- /**
|
|
|
- * @internal
|
|
|
- */
|
|
|
- var EditorSimpleWorkerImpl = (function (_super) {
|
|
|
- __extends(EditorSimpleWorkerImpl, _super);
|
|
|
- function EditorSimpleWorkerImpl() {
|
|
|
- var _this = _super.call(this) || this;
|
|
|
- _this._models = Object.create(null);
|
|
|
- return _this;
|
|
|
- }
|
|
|
- EditorSimpleWorkerImpl.prototype.dispose = function () {
|
|
|
- this._models = Object.create(null);
|
|
|
- };
|
|
|
- EditorSimpleWorkerImpl.prototype._getModel = function (uri) {
|
|
|
- return this._models[uri];
|
|
|
- };
|
|
|
- EditorSimpleWorkerImpl.prototype._getModels = function () {
|
|
|
- var _this = this;
|
|
|
- var all = [];
|
|
|
- Object.keys(this._models).forEach(function (key) { return all.push(_this._models[key]); });
|
|
|
- return all;
|
|
|
- };
|
|
|
- EditorSimpleWorkerImpl.prototype.acceptNewModel = function (data) {
|
|
|
- this._models[data.url] = new MirrorModel(uri_1.default.parse(data.url), data.lines, data.EOL, data.versionId);
|
|
|
- };
|
|
|
- EditorSimpleWorkerImpl.prototype.acceptModelChanged = function (strURL, e) {
|
|
|
- if (!this._models[strURL]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- var model = this._models[strURL];
|
|
|
- model.onEvents(e);
|
|
|
- };
|
|
|
- EditorSimpleWorkerImpl.prototype.acceptRemovedModel = function (strURL) {
|
|
|
- if (!this._models[strURL]) {
|
|
|
- return;
|
|
|
- }
|
|
|
- delete this._models[strURL];
|
|
|
- };
|
|
|
- return EditorSimpleWorkerImpl;
|
|
|
- }(BaseEditorSimpleWorker));
|
|
|
- exports.EditorSimpleWorkerImpl = EditorSimpleWorkerImpl;
|
|
|
- /**
|
|
|
- * Called on the worker side
|
|
|
- * @internal
|
|
|
- */
|
|
|
- function create() {
|
|
|
- return new EditorSimpleWorkerImpl();
|
|
|
- }
|
|
|
- exports.create = create;
|
|
|
- var global = self;
|
|
|
- var isWebWorker = (typeof global.importScripts === 'function');
|
|
|
- if (isWebWorker) {
|
|
|
- global.monaco = standaloneBase_1.createMonacoBaseAPI();
|
|
|
- }
|
|
|
-});
|
|
|
-
|
|
|
-/*---------------------------------------------------------------------------------------------
|
|
|
- * Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
- * Licensed under the MIT License. See License.txt in the project root for license information.
|
|
|
- *--------------------------------------------------------------------------------------------*/
|
|
|
-(function () {
|
|
|
- 'use strict';
|
|
|
- var MonacoEnvironment = self.MonacoEnvironment;
|
|
|
- var monacoBaseUrl = MonacoEnvironment && MonacoEnvironment.baseUrl ? MonacoEnvironment.baseUrl : '../../../';
|
|
|
- if (typeof self.define !== 'function' || !self.define.amd) {
|
|
|
- importScripts(monacoBaseUrl + 'vs/loader.js');
|
|
|
- }
|
|
|
- require.config({
|
|
|
- baseUrl: monacoBaseUrl,
|
|
|
- catchError: true
|
|
|
- });
|
|
|
- var loadCode = function (moduleId) {
|
|
|
- require([moduleId], function (ws) {
|
|
|
- setTimeout(function () {
|
|
|
- var messageHandler = ws.create(function (msg) {
|
|
|
- self.postMessage(msg);
|
|
|
- }, null);
|
|
|
- self.onmessage = function (e) { return messageHandler.onmessage(e.data); };
|
|
|
- while (beforeReadyMessages.length > 0) {
|
|
|
- self.onmessage(beforeReadyMessages.shift());
|
|
|
- }
|
|
|
- }, 0);
|
|
|
- });
|
|
|
- };
|
|
|
- var isFirstMessage = true;
|
|
|
- var beforeReadyMessages = [];
|
|
|
- self.onmessage = function (message) {
|
|
|
- if (!isFirstMessage) {
|
|
|
- beforeReadyMessages.push(message);
|
|
|
- return;
|
|
|
- }
|
|
|
- isFirstMessage = false;
|
|
|
- loadCode(message.data);
|
|
|
- };
|
|
|
-})();
|
|
|
-
|
|
|
-}).call(this);
|
|
|
-//# sourceMappingURL=workerMain.js.map
|
Shaddock Heath