@easyv/biz-components 0.0.52-beta.0 → 0.0.52-beta.1

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inPlaceReplace.es.js","sources":["../../../../../../../../../../../../../../node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplace.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nvar InPlaceReplaceController_1;\nimport { createCancelablePromise, timeout } from '../../../../base/common/async.js';\nimport { onUnexpectedError } from '../../../../base/common/errors.js';\nimport { EditorState } from '../../editorState/browser/editorState.js';\nimport { EditorAction, registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.js';\nimport { Range } from '../../../common/core/range.js';\nimport { Selection } from '../../../common/core/selection.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { ModelDecorationOptions } from '../../../common/model/textModel.js';\nimport { IEditorWorkerService } from '../../../common/services/editorWorker.js';\nimport * as nls from '../../../../nls.js';\nimport { InPlaceReplaceCommand } from './inPlaceReplaceCommand.js';\nimport './inPlaceReplace.css';\nlet InPlaceReplaceController = class InPlaceReplaceController {\n    static { InPlaceReplaceController_1 = this; }\n    static { this.ID = 'editor.contrib.inPlaceReplaceController'; }\n    static get(editor) {\n        return editor.getContribution(InPlaceReplaceController_1.ID);\n    }\n    static { this.DECORATION = ModelDecorationOptions.register({\n        description: 'in-place-replace',\n        className: 'valueSetReplacement'\n    }); }\n    constructor(editor, editorWorkerService) {\n        this.editor = editor;\n        this.editorWorkerService = editorWorkerService;\n        this.decorations = this.editor.createDecorationsCollection();\n    }\n    dispose() {\n    }\n    run(source, up) {\n        // cancel any pending request\n        this.currentRequest?.cancel();\n        const editorSelection = this.editor.getSelection();\n        const model = this.editor.getModel();\n        if (!model || !editorSelection) {\n            return undefined;\n        }\n        let selection = editorSelection;\n        if (selection.startLineNumber !== selection.endLineNumber) {\n            // Can't accept multiline selection\n            return undefined;\n        }\n        const state = new EditorState(this.editor, 1 /* CodeEditorStateFlag.Value */ | 4 /* CodeEditorStateFlag.Position */);\n        const modelURI = model.uri;\n        if (!this.editorWorkerService.canNavigateValueSet(modelURI)) {\n            return Promise.resolve(undefined);\n        }\n        this.currentRequest = createCancelablePromise(token => this.editorWorkerService.navigateValueSet(modelURI, selection, up));\n        return this.currentRequest.then(result => {\n            if (!result || !result.range || !result.value) {\n                // No proper result\n                return;\n            }\n            if (!state.validate(this.editor)) {\n                // state has changed\n                return;\n            }\n            // Selection\n            const editRange = Range.lift(result.range);\n            let highlightRange = result.range;\n            const diff = result.value.length - (selection.endColumn - selection.startColumn);\n            // highlight\n            highlightRange = {\n                startLineNumber: highlightRange.startLineNumber,\n                startColumn: highlightRange.startColumn,\n                endLineNumber: highlightRange.endLineNumber,\n                endColumn: highlightRange.startColumn + result.value.length\n            };\n            if (diff > 1) {\n                selection = new Selection(selection.startLineNumber, selection.startColumn, selection.endLineNumber, selection.endColumn + diff - 1);\n            }\n            // Insert new text\n            const command = new InPlaceReplaceCommand(editRange, selection, result.value);\n            this.editor.pushUndoStop();\n            this.editor.executeCommand(source, command);\n            this.editor.pushUndoStop();\n            // add decoration\n            this.decorations.set([{\n                    range: highlightRange,\n                    options: InPlaceReplaceController_1.DECORATION\n                }]);\n            // remove decoration after delay\n            this.decorationRemover?.cancel();\n            this.decorationRemover = timeout(350);\n            this.decorationRemover.then(() => this.decorations.clear()).catch(onUnexpectedError);\n        }).catch(onUnexpectedError);\n    }\n};\nInPlaceReplaceController = InPlaceReplaceController_1 = __decorate([\n    __param(1, IEditorWorkerService)\n], InPlaceReplaceController);\nclass InPlaceReplaceUp extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.inPlaceReplace.up',\n            label: nls.localize('InPlaceReplaceAction.previous.label', \"Replace with Previous Value\"),\n            alias: 'Replace with Previous Value',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 87 /* KeyCode.Comma */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(accessor, editor) {\n        const controller = InPlaceReplaceController.get(editor);\n        if (!controller) {\n            return Promise.resolve(undefined);\n        }\n        return controller.run(this.id, false);\n    }\n}\nclass InPlaceReplaceDown extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.inPlaceReplace.down',\n            label: nls.localize('InPlaceReplaceAction.next.label', \"Replace with Next Value\"),\n            alias: 'Replace with Next Value',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 89 /* KeyCode.Period */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(accessor, editor) {\n        const controller = InPlaceReplaceController.get(editor);\n        if (!controller) {\n            return Promise.resolve(undefined);\n        }\n        return controller.run(this.id, true);\n    }\n}\nregisterEditorContribution(InPlaceReplaceController.ID, InPlaceReplaceController, 4 /* EditorContributionInstantiation.Lazy */);\nregisterEditorAction(InPlaceReplaceUp);\nregisterEditorAction(InPlaceReplaceDown);\n"],"names":["_a","nls.localize"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplaceCommand.es.js

@@ -0,0 +1,23 @@
+import { Selection } from "../../../common/core/selection.es.js";
+class InPlaceReplaceCommand {
+  constructor(editRange, originalSelection, text) {
+    this._editRange = editRange;
+    this._originalSelection = originalSelection;
+    this._text = text;
+  }
+  getEditOperations(model, builder) {
+    builder.addTrackedEditOperation(this._editRange, this._text);
+  }
+  computeCursorState(model, helper) {
+    const inverseEditOperations = helper.getInverseEditOperations();
+    const srcRange = inverseEditOperations[0].range;
+    if (!this._originalSelection.isEmpty()) {
+      return new Selection(srcRange.endLineNumber, srcRange.endColumn - this._text.length, srcRange.endLineNumber, srcRange.endColumn);
+    }
+    return new Selection(srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn), srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn));
+  }
+}
+export {
+  InPlaceReplaceCommand
+};
+//# sourceMappingURL=inPlaceReplaceCommand.es.js.map

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplaceCommand.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inPlaceReplaceCommand.es.js","sources":["../../../../../../../../../../../../../../node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/inPlaceReplace/browser/inPlaceReplaceCommand.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Selection } from '../../../common/core/selection.js';\nexport class InPlaceReplaceCommand {\n    constructor(editRange, originalSelection, text) {\n        this._editRange = editRange;\n        this._originalSelection = originalSelection;\n        this._text = text;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._editRange, this._text);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const srcRange = inverseEditOperations[0].range;\n        if (!this._originalSelection.isEmpty()) {\n            // Preserve selection and extends to typed text\n            return new Selection(srcRange.endLineNumber, srcRange.endColumn - this._text.length, srcRange.endLineNumber, srcRange.endColumn);\n        }\n        return new Selection(srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn), srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn));\n    }\n}\n"],"names":[],"mappings":";AAKO,MAAM,sBAAsB;AAAA,EAC/B,YAAY,WAAW,mBAAmB,MAAM;AAC5C,SAAK,aAAa;AAClB,SAAK,qBAAqB;AAC1B,SAAK,QAAQ;AAAA,EACrB;AAAA,EACI,kBAAkB,OAAO,SAAS;AAC9B,YAAQ,wBAAwB,KAAK,YAAY,KAAK,KAAK;AAAA,EACnE;AAAA,EACI,mBAAmB,OAAO,QAAQ;AAC9B,UAAM,wBAAwB,OAAO,yBAA0B;AAC/D,UAAM,WAAW,sBAAsB,CAAC,EAAE;AAC1C,QAAI,CAAC,KAAK,mBAAmB,WAAW;AAEpC,aAAO,IAAI,UAAU,SAAS,eAAe,SAAS,YAAY,KAAK,MAAM,QAAQ,SAAS,eAAe,SAAS,SAAS;AAAA,IAC3I;AACQ,WAAO,IAAI,UAAU,SAAS,eAAe,KAAK,IAAI,KAAK,mBAAmB,gBAAgB,SAAS,SAAS,GAAG,SAAS,eAAe,KAAK,IAAI,KAAK,mBAAmB,gBAAgB,SAAS,SAAS,CAAC;AAAA,EACvN;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/indentation/browser/indentation.es.js

@@ -0,0 +1,605 @@
+var _a;
+import { DisposableStore } from "../../../../base/common/lifecycle.es.js";
+import { getLeadingWhitespace } from "../../../../base/common/strings.es.js";
+import { EditorAction, registerEditorContribution, registerEditorAction } from "../../../browser/editorExtensions.es.js";
+import { ShiftCommand } from "../../../common/commands/shiftCommand.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { EditorContextKeys } from "../../../common/editorContextKeys.es.js";
+import { ILanguageConfigurationService } from "../../../common/languages/languageConfigurationRegistry.es.js";
+import { IModelService } from "../../../common/services/model.es.js";
+import { getSpaceCnt, generateIndent } from "../common/indentUtils.es.js";
+import { localize2, localize } from "../../../../nls.es.js";
+import { IQuickInputService } from "../../../../platform/quickinput/common/quickInput.es.js";
+import { getGoodIndentForLine, getIndentMetadata } from "../../../common/languages/autoIndent.es.js";
+import { getReindentEditOperations } from "../common/indentation.es.js";
+import { getStandardTokenTypeAtPosition } from "../../../common/tokens/lineTokens.es.js";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+const _IndentationToSpacesAction = class _IndentationToSpacesAction extends EditorAction {
+  constructor() {
+    super({
+      id: _IndentationToSpacesAction.ID,
+      label: localize("indentationToSpaces", "Convert Indentation to Spaces"),
+      alias: "Convert Indentation to Spaces",
+      precondition: EditorContextKeys.writable,
+      metadata: {
+        description: localize2("indentationToSpacesDescription", "Convert the tab indentation to spaces.")
+      }
+    });
+  }
+  run(accessor, editor) {
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const modelOpts = model.getOptions();
+    const selection = editor.getSelection();
+    if (!selection) {
+      return;
+    }
+    const command = new IndentationToSpacesCommand(selection, modelOpts.tabSize);
+    editor.pushUndoStop();
+    editor.executeCommands(this.id, [command]);
+    editor.pushUndoStop();
+    model.updateOptions({
+      insertSpaces: true
+    });
+  }
+};
+_IndentationToSpacesAction.ID = "editor.action.indentationToSpaces";
+let IndentationToSpacesAction = _IndentationToSpacesAction;
+const _IndentationToTabsAction = class _IndentationToTabsAction extends EditorAction {
+  constructor() {
+    super({
+      id: _IndentationToTabsAction.ID,
+      label: localize("indentationToTabs", "Convert Indentation to Tabs"),
+      alias: "Convert Indentation to Tabs",
+      precondition: EditorContextKeys.writable,
+      metadata: {
+        description: localize2("indentationToTabsDescription", "Convert the spaces indentation to tabs.")
+      }
+    });
+  }
+  run(accessor, editor) {
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const modelOpts = model.getOptions();
+    const selection = editor.getSelection();
+    if (!selection) {
+      return;
+    }
+    const command = new IndentationToTabsCommand(selection, modelOpts.tabSize);
+    editor.pushUndoStop();
+    editor.executeCommands(this.id, [command]);
+    editor.pushUndoStop();
+    model.updateOptions({
+      insertSpaces: false
+    });
+  }
+};
+_IndentationToTabsAction.ID = "editor.action.indentationToTabs";
+let IndentationToTabsAction = _IndentationToTabsAction;
+class ChangeIndentationSizeAction extends EditorAction {
+  constructor(insertSpaces, displaySizeOnly, opts) {
+    super(opts);
+    this.insertSpaces = insertSpaces;
+    this.displaySizeOnly = displaySizeOnly;
+  }
+  run(accessor, editor) {
+    const quickInputService = accessor.get(IQuickInputService);
+    const modelService = accessor.get(IModelService);
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const creationOpts = modelService.getCreationOptions(model.getLanguageId(), model.uri, model.isForSimpleWidget);
+    const modelOpts = model.getOptions();
+    const picks = [1, 2, 3, 4, 5, 6, 7, 8].map((n) => ({
+      id: n.toString(),
+      label: n.toString(),
+      // add description for tabSize value set in the configuration
+      description: n === creationOpts.tabSize && n === modelOpts.tabSize ? localize("configuredTabSize", "Configured Tab Size") : n === creationOpts.tabSize ? localize("defaultTabSize", "Default Tab Size") : n === modelOpts.tabSize ? localize("currentTabSize", "Current Tab Size") : void 0
+    }));
+    const autoFocusIndex = Math.min(model.getOptions().tabSize - 1, 7);
+    setTimeout(
+      () => {
+        quickInputService.pick(picks, { placeHolder: localize({ key: "selectTabWidth", comment: ["Tab corresponds to the tab key"] }, "Select Tab Size for Current File"), activeItem: picks[autoFocusIndex] }).then((pick) => {
+          if (pick) {
+            if (model && !model.isDisposed()) {
+              const pickedVal = parseInt(pick.label, 10);
+              if (this.displaySizeOnly) {
+                model.updateOptions({
+                  tabSize: pickedVal
+                });
+              } else {
+                model.updateOptions({
+                  tabSize: pickedVal,
+                  indentSize: pickedVal,
+                  insertSpaces: this.insertSpaces
+                });
+              }
+            }
+          }
+        });
+      },
+      50
+      /* quick input is sensitive to being opened so soon after another */
+    );
+  }
+}
+const _IndentUsingTabs = class _IndentUsingTabs extends ChangeIndentationSizeAction {
+  constructor() {
+    super(false, false, {
+      id: _IndentUsingTabs.ID,
+      label: localize("indentUsingTabs", "Indent Using Tabs"),
+      alias: "Indent Using Tabs",
+      precondition: void 0,
+      metadata: {
+        description: localize2("indentUsingTabsDescription", "Use indentation with tabs.")
+      }
+    });
+  }
+};
+_IndentUsingTabs.ID = "editor.action.indentUsingTabs";
+let IndentUsingTabs = _IndentUsingTabs;
+const _IndentUsingSpaces = class _IndentUsingSpaces extends ChangeIndentationSizeAction {
+  constructor() {
+    super(true, false, {
+      id: _IndentUsingSpaces.ID,
+      label: localize("indentUsingSpaces", "Indent Using Spaces"),
+      alias: "Indent Using Spaces",
+      precondition: void 0,
+      metadata: {
+        description: localize2("indentUsingSpacesDescription", "Use indentation with spaces.")
+      }
+    });
+  }
+};
+_IndentUsingSpaces.ID = "editor.action.indentUsingSpaces";
+let IndentUsingSpaces = _IndentUsingSpaces;
+const _ChangeTabDisplaySize = class _ChangeTabDisplaySize extends ChangeIndentationSizeAction {
+  constructor() {
+    super(true, true, {
+      id: _ChangeTabDisplaySize.ID,
+      label: localize("changeTabDisplaySize", "Change Tab Display Size"),
+      alias: "Change Tab Display Size",
+      precondition: void 0,
+      metadata: {
+        description: localize2("changeTabDisplaySizeDescription", "Change the space size equivalent of the tab.")
+      }
+    });
+  }
+};
+_ChangeTabDisplaySize.ID = "editor.action.changeTabDisplaySize";
+let ChangeTabDisplaySize = _ChangeTabDisplaySize;
+const _DetectIndentation = class _DetectIndentation extends EditorAction {
+  constructor() {
+    super({
+      id: _DetectIndentation.ID,
+      label: localize("detectIndentation", "Detect Indentation from Content"),
+      alias: "Detect Indentation from Content",
+      precondition: void 0,
+      metadata: {
+        description: localize2("detectIndentationDescription", "Detect the indentation from content.")
+      }
+    });
+  }
+  run(accessor, editor) {
+    const modelService = accessor.get(IModelService);
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const creationOpts = modelService.getCreationOptions(model.getLanguageId(), model.uri, model.isForSimpleWidget);
+    model.detectIndentation(creationOpts.insertSpaces, creationOpts.tabSize);
+  }
+};
+_DetectIndentation.ID = "editor.action.detectIndentation";
+let DetectIndentation = _DetectIndentation;
+class ReindentLinesAction extends EditorAction {
+  constructor() {
+    super({
+      id: "editor.action.reindentlines",
+      label: localize("editor.reindentlines", "Reindent Lines"),
+      alias: "Reindent Lines",
+      precondition: EditorContextKeys.writable,
+      metadata: {
+        description: localize2("editor.reindentlinesDescription", "Reindent the lines of the editor.")
+      }
+    });
+  }
+  run(accessor, editor) {
+    const languageConfigurationService = accessor.get(ILanguageConfigurationService);
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const edits = getReindentEditOperations(model, languageConfigurationService, 1, model.getLineCount());
+    if (edits.length > 0) {
+      editor.pushUndoStop();
+      editor.executeEdits(this.id, edits);
+      editor.pushUndoStop();
+    }
+  }
+}
+class ReindentSelectedLinesAction extends EditorAction {
+  constructor() {
+    super({
+      id: "editor.action.reindentselectedlines",
+      label: localize("editor.reindentselectedlines", "Reindent Selected Lines"),
+      alias: "Reindent Selected Lines",
+      precondition: EditorContextKeys.writable,
+      metadata: {
+        description: localize2("editor.reindentselectedlinesDescription", "Reindent the selected lines of the editor.")
+      }
+    });
+  }
+  run(accessor, editor) {
+    const languageConfigurationService = accessor.get(ILanguageConfigurationService);
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const selections = editor.getSelections();
+    if (selections === null) {
+      return;
+    }
+    const edits = [];
+    for (const selection of selections) {
+      let startLineNumber = selection.startLineNumber;
+      let endLineNumber = selection.endLineNumber;
+      if (startLineNumber !== endLineNumber && selection.endColumn === 1) {
+        endLineNumber--;
+      }
+      if (startLineNumber === 1) {
+        if (startLineNumber === endLineNumber) {
+          continue;
+        }
+      } else {
+        startLineNumber--;
+      }
+      const editOperations = getReindentEditOperations(model, languageConfigurationService, startLineNumber, endLineNumber);
+      edits.push(...editOperations);
+    }
+    if (edits.length > 0) {
+      editor.pushUndoStop();
+      editor.executeEdits(this.id, edits);
+      editor.pushUndoStop();
+    }
+  }
+}
+class AutoIndentOnPasteCommand {
+  constructor(edits, initialSelection) {
+    this._initialSelection = initialSelection;
+    this._edits = [];
+    this._selectionId = null;
+    for (const edit of edits) {
+      if (edit.range && typeof edit.text === "string") {
+        this._edits.push(edit);
+      }
+    }
+  }
+  getEditOperations(model, builder) {
+    for (const edit of this._edits) {
+      builder.addEditOperation(Range.lift(edit.range), edit.text);
+    }
+    let selectionIsSet = false;
+    if (Array.isArray(this._edits) && this._edits.length === 1 && this._initialSelection.isEmpty()) {
+      if (this._edits[0].range.startColumn === this._initialSelection.endColumn && this._edits[0].range.startLineNumber === this._initialSelection.endLineNumber) {
+        selectionIsSet = true;
+        this._selectionId = builder.trackSelection(this._initialSelection, true);
+      } else if (this._edits[0].range.endColumn === this._initialSelection.startColumn && this._edits[0].range.endLineNumber === this._initialSelection.startLineNumber) {
+        selectionIsSet = true;
+        this._selectionId = builder.trackSelection(this._initialSelection, false);
+      }
+    }
+    if (!selectionIsSet) {
+      this._selectionId = builder.trackSelection(this._initialSelection);
+    }
+  }
+  computeCursorState(model, helper) {
+    return helper.getTrackedSelection(this._selectionId);
+  }
+}
+let AutoIndentOnPaste = (_a = class {
+  constructor(editor, _languageConfigurationService) {
+    this.editor = editor;
+    this._languageConfigurationService = _languageConfigurationService;
+    this.callOnDispose = new DisposableStore();
+    this.callOnModel = new DisposableStore();
+    this.callOnDispose.add(editor.onDidChangeConfiguration(() => this.update()));
+    this.callOnDispose.add(editor.onDidChangeModel(() => this.update()));
+    this.callOnDispose.add(editor.onDidChangeModelLanguage(() => this.update()));
+  }
+  update() {
+    this.callOnModel.clear();
+    if (this.editor.getOption(
+      12
+      /* EditorOption.autoIndent */
+    ) < 4 || this.editor.getOption(
+      55
+      /* EditorOption.formatOnPaste */
+    )) {
+      return;
+    }
+    if (!this.editor.hasModel()) {
+      return;
+    }
+    this.callOnModel.add(this.editor.onDidPaste(({ range }) => {
+      this.trigger(range);
+    }));
+  }
+  trigger(range) {
+    const selections = this.editor.getSelections();
+    if (selections === null || selections.length > 1) {
+      return;
+    }
+    const model = this.editor.getModel();
+    if (!model) {
+      return;
+    }
+    const containsOnlyWhitespace = this.rangeContainsOnlyWhitespaceCharacters(model, range);
+    if (containsOnlyWhitespace) {
+      return;
+    }
+    if (isStartOrEndInString(model, range)) {
+      return;
+    }
+    if (!model.tokenization.isCheapToTokenize(range.getStartPosition().lineNumber)) {
+      return;
+    }
+    const autoIndent = this.editor.getOption(
+      12
+      /* EditorOption.autoIndent */
+    );
+    const { tabSize, indentSize, insertSpaces } = model.getOptions();
+    const textEdits = [];
+    const indentConverter = {
+      shiftIndent: (indentation) => {
+        return ShiftCommand.shiftIndent(indentation, indentation.length + 1, tabSize, indentSize, insertSpaces);
+      },
+      unshiftIndent: (indentation) => {
+        return ShiftCommand.unshiftIndent(indentation, indentation.length + 1, tabSize, indentSize, insertSpaces);
+      }
+    };
+    let startLineNumber = range.startLineNumber;
+    while (startLineNumber <= range.endLineNumber) {
+      if (this.shouldIgnoreLine(model, startLineNumber)) {
+        startLineNumber++;
+        continue;
+      }
+      break;
+    }
+    if (startLineNumber > range.endLineNumber) {
+      return;
+    }
+    let firstLineText = model.getLineContent(startLineNumber);
+    if (!/\S/.test(firstLineText.substring(0, range.startColumn - 1))) {
+      const indentOfFirstLine = getGoodIndentForLine(autoIndent, model, model.getLanguageId(), startLineNumber, indentConverter, this._languageConfigurationService);
+      if (indentOfFirstLine !== null) {
+        const oldIndentation = getLeadingWhitespace(firstLineText);
+        const newSpaceCnt = getSpaceCnt(indentOfFirstLine, tabSize);
+        const oldSpaceCnt = getSpaceCnt(oldIndentation, tabSize);
+        if (newSpaceCnt !== oldSpaceCnt) {
+          const newIndent = generateIndent(newSpaceCnt, tabSize, insertSpaces);
+          textEdits.push({
+            range: new Range(startLineNumber, 1, startLineNumber, oldIndentation.length + 1),
+            text: newIndent
+          });
+          firstLineText = newIndent + firstLineText.substring(oldIndentation.length);
+        } else {
+          const indentMetadata = getIndentMetadata(model, startLineNumber, this._languageConfigurationService);
+          if (indentMetadata === 0 || indentMetadata === 8) {
+            return;
+          }
+        }
+      }
+    }
+    const firstLineNumber = startLineNumber;
+    while (startLineNumber < range.endLineNumber) {
+      if (!/\S/.test(model.getLineContent(startLineNumber + 1))) {
+        startLineNumber++;
+        continue;
+      }
+      break;
+    }
+    if (startLineNumber !== range.endLineNumber) {
+      const virtualModel = {
+        tokenization: {
+          getLineTokens: (lineNumber) => {
+            return model.tokenization.getLineTokens(lineNumber);
+          },
+          getLanguageId: () => {
+            return model.getLanguageId();
+          },
+          getLanguageIdAtPosition: (lineNumber, column) => {
+            return model.getLanguageIdAtPosition(lineNumber, column);
+          }
+        },
+        getLineContent: (lineNumber) => {
+          if (lineNumber === firstLineNumber) {
+            return firstLineText;
+          } else {
+            return model.getLineContent(lineNumber);
+          }
+        }
+      };
+      const indentOfSecondLine = getGoodIndentForLine(autoIndent, virtualModel, model.getLanguageId(), startLineNumber + 1, indentConverter, this._languageConfigurationService);
+      if (indentOfSecondLine !== null) {
+        const newSpaceCntOfSecondLine = getSpaceCnt(indentOfSecondLine, tabSize);
+        const oldSpaceCntOfSecondLine = getSpaceCnt(getLeadingWhitespace(model.getLineContent(startLineNumber + 1)), tabSize);
+        if (newSpaceCntOfSecondLine !== oldSpaceCntOfSecondLine) {
+          const spaceCntOffset = newSpaceCntOfSecondLine - oldSpaceCntOfSecondLine;
+          for (let i = startLineNumber + 1; i <= range.endLineNumber; i++) {
+            const lineContent = model.getLineContent(i);
+            const originalIndent = getLeadingWhitespace(lineContent);
+            const originalSpacesCnt = getSpaceCnt(originalIndent, tabSize);
+            const newSpacesCnt = originalSpacesCnt + spaceCntOffset;
+            const newIndent = generateIndent(newSpacesCnt, tabSize, insertSpaces);
+            if (newIndent !== originalIndent) {
+              textEdits.push({
+                range: new Range(i, 1, i, originalIndent.length + 1),
+                text: newIndent
+              });
+            }
+          }
+        }
+      }
+    }
+    if (textEdits.length > 0) {
+      this.editor.pushUndoStop();
+      const cmd = new AutoIndentOnPasteCommand(textEdits, this.editor.getSelection());
+      this.editor.executeCommand("autoIndentOnPaste", cmd);
+      this.editor.pushUndoStop();
+    }
+  }
+  rangeContainsOnlyWhitespaceCharacters(model, range) {
+    const lineContainsOnlyWhitespace = (content) => {
+      return content.trim().length === 0;
+    };
+    let containsOnlyWhitespace = true;
+    if (range.startLineNumber === range.endLineNumber) {
+      const lineContent = model.getLineContent(range.startLineNumber);
+      const linePart = lineContent.substring(range.startColumn - 1, range.endColumn - 1);
+      containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+    } else {
+      for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {
+        const lineContent = model.getLineContent(i);
+        if (i === range.startLineNumber) {
+          const linePart = lineContent.substring(range.startColumn - 1);
+          containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+        } else if (i === range.endLineNumber) {
+          const linePart = lineContent.substring(0, range.endColumn - 1);
+          containsOnlyWhitespace = lineContainsOnlyWhitespace(linePart);
+        } else {
+          containsOnlyWhitespace = model.getLineFirstNonWhitespaceColumn(i) === 0;
+        }
+        if (!containsOnlyWhitespace) {
+          break;
+        }
+      }
+    }
+    return containsOnlyWhitespace;
+  }
+  shouldIgnoreLine(model, lineNumber) {
+    model.tokenization.forceTokenization(lineNumber);
+    const nonWhitespaceColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+    if (nonWhitespaceColumn === 0) {
+      return true;
+    }
+    const tokens = model.tokenization.getLineTokens(lineNumber);
+    if (tokens.getCount() > 0) {
+      const firstNonWhitespaceTokenIndex = tokens.findTokenIndexAtOffset(nonWhitespaceColumn);
+      if (firstNonWhitespaceTokenIndex >= 0 && tokens.getStandardTokenType(firstNonWhitespaceTokenIndex) === 1) {
+        return true;
+      }
+    }
+    return false;
+  }
+  dispose() {
+    this.callOnDispose.dispose();
+    this.callOnModel.dispose();
+  }
+}, _a.ID = "editor.contrib.autoIndentOnPaste", _a);
+AutoIndentOnPaste = __decorate([
+  __param(1, ILanguageConfigurationService)
+], AutoIndentOnPaste);
+function isStartOrEndInString(model, range) {
+  const isPositionInString = (position) => {
+    const tokenType = getStandardTokenTypeAtPosition(model, position);
+    return tokenType === 2;
+  };
+  return isPositionInString(range.getStartPosition()) || isPositionInString(range.getEndPosition());
+}
+function getIndentationEditOperations(model, builder, tabSize, tabsToSpaces) {
+  if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
+    return;
+  }
+  let spaces = "";
+  for (let i = 0; i < tabSize; i++) {
+    spaces += " ";
+  }
+  const spacesRegExp = new RegExp(spaces, "gi");
+  for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
+    let lastIndentationColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+    if (lastIndentationColumn === 0) {
+      lastIndentationColumn = model.getLineMaxColumn(lineNumber);
+    }
+    if (lastIndentationColumn === 1) {
+      continue;
+    }
+    const originalIndentationRange = new Range(lineNumber, 1, lineNumber, lastIndentationColumn);
+    const originalIndentation = model.getValueInRange(originalIndentationRange);
+    const newIndentation = tabsToSpaces ? originalIndentation.replace(/\t/ig, spaces) : originalIndentation.replace(spacesRegExp, "	");
+    builder.addEditOperation(originalIndentationRange, newIndentation);
+  }
+}
+class IndentationToSpacesCommand {
+  constructor(selection, tabSize) {
+    this.selection = selection;
+    this.tabSize = tabSize;
+    this.selectionId = null;
+  }
+  getEditOperations(model, builder) {
+    this.selectionId = builder.trackSelection(this.selection);
+    getIndentationEditOperations(model, builder, this.tabSize, true);
+  }
+  computeCursorState(model, helper) {
+    return helper.getTrackedSelection(this.selectionId);
+  }
+}
+class IndentationToTabsCommand {
+  constructor(selection, tabSize) {
+    this.selection = selection;
+    this.tabSize = tabSize;
+    this.selectionId = null;
+  }
+  getEditOperations(model, builder) {
+    this.selectionId = builder.trackSelection(this.selection);
+    getIndentationEditOperations(model, builder, this.tabSize, false);
+  }
+  computeCursorState(model, helper) {
+    return helper.getTrackedSelection(this.selectionId);
+  }
+}
+registerEditorContribution(
+  AutoIndentOnPaste.ID,
+  AutoIndentOnPaste,
+  2
+  /* EditorContributionInstantiation.BeforeFirstInteraction */
+);
+registerEditorAction(IndentationToSpacesAction);
+registerEditorAction(IndentationToTabsAction);
+registerEditorAction(IndentUsingTabs);
+registerEditorAction(IndentUsingSpaces);
+registerEditorAction(ChangeTabDisplaySize);
+registerEditorAction(DetectIndentation);
+registerEditorAction(ReindentLinesAction);
+registerEditorAction(ReindentSelectedLinesAction);
+export {
+  AutoIndentOnPaste,
+  AutoIndentOnPasteCommand,
+  ChangeIndentationSizeAction,
+  ChangeTabDisplaySize,
+  DetectIndentation,
+  IndentUsingSpaces,
+  IndentUsingTabs,
+  IndentationToSpacesAction,
+  IndentationToSpacesCommand,
+  IndentationToTabsAction,
+  IndentationToTabsCommand,
+  ReindentLinesAction,
+  ReindentSelectedLinesAction
+};
+//# sourceMappingURL=indentation.es.js.map