Repository: kendryte/kendryte-ide
Branch: development
Commit: e7a289810b81
Files: 4308
Total size: 38.9 MB
Directory structure:
gitextract_8ys7dl2c/
├── .editorconfig
├── .eslintrc.json
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── feature_request.md
│ │ ├── question.md
│ │ └── question_cn.md
│ ├── calendar.yml
│ ├── classifier.yml
│ ├── commands.yml
│ ├── copycat.yml
│ ├── endgame/
│ │ └── insiders.yml
│ ├── insiders.yml
│ ├── locker.yml
│ ├── needs_more_info.yml
│ ├── new_release.yml
│ ├── pull_request_template.md
│ └── similarity.yml
├── .gitignore
├── .idea/
│ ├── codeStyles/
│ │ ├── Project.xml
│ │ └── codeStyleConfig.xml
│ ├── compiler.xml
│ ├── dictionaries/
│ │ └── gongt.xml
│ ├── encodings.xml
│ ├── misc.xml
│ ├── modules.xml
│ ├── project.iml
│ ├── vcs.xml
│ └── watcherTasks.xml
├── .mention-bot
├── .nvmrc
├── .prettierrc.json
├── .vscode/
│ ├── cglicenses.schema.json
│ ├── cgmanifest.schema.json
│ ├── extensions.json
│ ├── launch.json
│ ├── settings.json
│ ├── shared.code-snippets
│ └── tasks.json
├── .yarnrc
├── CONTRIBUTING.md
├── LICENSE.txt
├── README.md
├── ThirdPartyNotices.txt
├── azure-pipelines.yml
├── build/
│ ├── .cachesalt
│ ├── .nativeignore
│ ├── azure-pipelines/
│ │ ├── common/
│ │ │ ├── .gitignore
│ │ │ ├── extract-telemetry.sh
│ │ │ ├── publish-webview.sh
│ │ │ ├── publish-webview.ts
│ │ │ ├── publish.ts
│ │ │ ├── release.ts
│ │ │ ├── symbols.ts
│ │ │ ├── sync-mooncake.ts
│ │ │ └── telemetry-config.json
│ │ ├── darwin/
│ │ │ ├── continuous-build-darwin.yml
│ │ │ ├── product-build-darwin.yml
│ │ │ └── publish.sh
│ │ ├── distro-build.yml
│ │ ├── exploration-build.yml
│ │ ├── linux/
│ │ │ ├── .gitignore
│ │ │ ├── continuous-build-linux.yml
│ │ │ ├── frozen-check.js
│ │ │ ├── multiarch/
│ │ │ │ ├── alpine/
│ │ │ │ │ ├── build.sh
│ │ │ │ │ ├── prebuild.sh
│ │ │ │ │ └── publish.sh
│ │ │ │ ├── arm64/
│ │ │ │ │ ├── build.sh
│ │ │ │ │ ├── prebuild.sh
│ │ │ │ │ └── publish.sh
│ │ │ │ └── armhf/
│ │ │ │ ├── build.sh
│ │ │ │ ├── prebuild.sh
│ │ │ │ └── publish.sh
│ │ │ ├── product-build-linux-multiarch.yml
│ │ │ ├── product-build-linux.yml
│ │ │ ├── publish.sh
│ │ │ ├── snap-build-linux.yml
│ │ │ └── xvfb.init
│ │ ├── mixin.js
│ │ ├── product-build.yml
│ │ ├── product-compile.yml
│ │ ├── publish-types/
│ │ │ ├── .gitignore
│ │ │ ├── check-version.ts
│ │ │ ├── publish-types.yml
│ │ │ └── update-types.ts
│ │ ├── release.yml
│ │ ├── sync-mooncake.yml
│ │ ├── upload-sourcemaps.js
│ │ ├── web/
│ │ │ ├── product-build-web.yml
│ │ │ └── publish.sh
│ │ └── win32/
│ │ ├── ESRPClient/
│ │ │ ├── NuGet.config
│ │ │ └── packages.config
│ │ ├── continuous-build-win32.yml
│ │ ├── exec.ps1
│ │ ├── import-esrp-auth-cert.ps1
│ │ ├── product-build-win32.yml
│ │ ├── publish.ps1
│ │ └── sign.ps1
│ ├── builtInExtensions.json
│ ├── builtin/
│ │ ├── .eslintrc
│ │ ├── browser-main.js
│ │ ├── index.html
│ │ ├── main.js
│ │ └── package.json
│ ├── dependencies.js
│ ├── gulpfile.compile.js
│ ├── gulpfile.editor.js
│ ├── gulpfile.extensions.js
│ ├── gulpfile.hygiene.js
│ ├── gulpfile.reh.js
│ ├── gulpfile.vscode.js
│ ├── gulpfile.vscode.linux.js
│ ├── gulpfile.vscode.web.js
│ ├── gulpfile.vscode.win32.js
│ ├── jsconfig.json
│ ├── lib/
│ │ ├── asar.js
│ │ ├── asar.ts
│ │ ├── builtInExtensions.js
│ │ ├── bundle.js
│ │ ├── bundle.ts
│ │ ├── compilation.js
│ │ ├── compilation.ts
│ │ ├── electron.js
│ │ ├── electron.ts
│ │ ├── extensions.js
│ │ ├── extensions.ts
│ │ ├── git.js
│ │ ├── git.ts
│ │ ├── i18n.js
│ │ ├── i18n.resources.json
│ │ ├── i18n.ts
│ │ ├── nls.js
│ │ ├── nls.ts
│ │ ├── node.js
│ │ ├── node.ts
│ │ ├── optimize.js
│ │ ├── optimize.ts
│ │ ├── reporter.js
│ │ ├── reporter.ts
│ │ ├── snapshotLoader.js
│ │ ├── snapshotLoader.ts
│ │ ├── standalone.js
│ │ ├── standalone.ts
│ │ ├── stats.js
│ │ ├── stats.ts
│ │ ├── task.js
│ │ ├── task.ts
│ │ ├── test/
│ │ │ ├── i18n.test.js
│ │ │ └── i18n.test.ts
│ │ ├── treeshaking.js
│ │ ├── treeshaking.ts
│ │ ├── tslint/
│ │ │ ├── abstractGlobalsRule.js
│ │ │ ├── abstractGlobalsRule.ts
│ │ │ ├── duplicateImportsRule.js
│ │ │ ├── duplicateImportsRule.ts
│ │ │ ├── importPatternsRule.js
│ │ │ ├── importPatternsRule.ts
│ │ │ ├── layeringRule.js
│ │ │ ├── layeringRule.ts
│ │ │ ├── noDomGlobalsRule.js
│ │ │ ├── noDomGlobalsRule.ts
│ │ │ ├── noNewBufferRule.js
│ │ │ ├── noNewBufferRule.ts
│ │ │ ├── noNlsInStandaloneEditorRule.js
│ │ │ ├── noNlsInStandaloneEditorRule.ts
│ │ │ ├── noNodejsGlobalsRule.js
│ │ │ ├── noNodejsGlobalsRule.ts
│ │ │ ├── noStandaloneEditorRule.js
│ │ │ ├── noStandaloneEditorRule.ts
│ │ │ ├── noUnexternalizedStringsRule.js
│ │ │ ├── noUnexternalizedStringsRule.ts
│ │ │ ├── translationRemindRule.js
│ │ │ └── translationRemindRule.ts
│ │ ├── typings/
│ │ │ ├── cgmanifest.json
│ │ │ ├── event-stream.d.ts
│ │ │ ├── github-releases.d.ts
│ │ │ ├── gulp-bom.d.ts
│ │ │ ├── gulp-cssnano.d.ts
│ │ │ ├── gulp-flatmap.d.ts
│ │ │ ├── gulp-remote-src.d.ts
│ │ │ ├── gulp-tsb.d.ts
│ │ │ ├── is.d.ts
│ │ │ ├── lazy.js.d.ts
│ │ │ └── vinyl.d.ts
│ │ ├── util.js
│ │ ├── util.ts
│ │ └── watch/
│ │ ├── .gitignore
│ │ ├── index.js
│ │ ├── package.json
│ │ └── watch-win32.js
│ ├── monaco/
│ │ ├── LICENSE
│ │ ├── README-npm.md
│ │ ├── README.md
│ │ ├── ThirdPartyNotices.txt
│ │ ├── api.js
│ │ ├── api.ts
│ │ ├── monaco.d.ts.recipe
│ │ ├── monaco.usage.recipe
│ │ ├── package.json
│ │ └── version.txt
│ ├── npm/
│ │ ├── postinstall.js
│ │ ├── preinstall.js
│ │ ├── update-all-grammars.js
│ │ ├── update-distro.js
│ │ ├── update-grammar.js
│ │ ├── update-localization-extension.js
│ │ └── update-theme.js
│ ├── package.json
│ ├── tsconfig.build.json
│ ├── tsconfig.json
│ ├── tslint.json
│ └── win32/
│ ├── .gitignore
│ ├── code.iss
│ └── i18n/
│ ├── Default.isl
│ ├── Default.ko.isl
│ ├── Default.zh-cn.isl
│ ├── Default.zh-tw.isl
│ ├── messages.de.isl
│ ├── messages.en.isl
│ ├── messages.es.isl
│ ├── messages.fr.isl
│ ├── messages.hu.isl
│ ├── messages.it.isl
│ ├── messages.ja.isl
│ ├── messages.ko.isl
│ ├── messages.pt-br.isl
│ ├── messages.ru.isl
│ ├── messages.tr.isl
│ ├── messages.zh-cn.isl
│ └── messages.zh-tw.isl
├── cglicenses.json
├── cgmanifest.json
├── extensions/
│ ├── bat/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── batchfile.snippets.json
│ │ ├── syntaxes/
│ │ │ └── batchfile.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.bat
│ │ └── colorize-results/
│ │ └── test_bat.json
│ ├── cgmanifest.json
│ ├── clojure/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── clojure.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.clj
│ │ └── colorize-results/
│ │ └── test_clj.json
│ ├── coffeescript/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── coffeescript.snippets.json
│ │ ├── syntaxes/
│ │ │ └── coffeescript.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-regex.coffee
│ │ │ └── test.coffee
│ │ └── colorize-results/
│ │ ├── test-regex_coffee.json
│ │ └── test_coffee.json
│ ├── configuration-editing/
│ │ ├── .vscodeignore
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── schemas/
│ │ │ ├── attachContainer.schema.json
│ │ │ └── devContainer.schema.json
│ │ ├── src/
│ │ │ ├── extension.ts
│ │ │ ├── settingsDocumentHelper.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ └── tsconfig.json
│ ├── cpp/
│ │ ├── .vscodeignore
│ │ ├── build/
│ │ │ └── update-grammars.js
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ ├── c.json
│ │ │ └── cpp.json
│ │ ├── syntaxes/
│ │ │ ├── c.tmLanguage.json
│ │ │ ├── cpp.embedded.macro.tmLanguage.json
│ │ │ ├── cpp.tmLanguage.json
│ │ │ └── platform.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-23630.cpp
│ │ │ ├── test-23850.cpp
│ │ │ ├── test-78769.cpp
│ │ │ ├── test-80644.cpp
│ │ │ ├── test.c
│ │ │ ├── test.cc
│ │ │ └── test.cpp
│ │ └── colorize-results/
│ │ ├── test-23630_cpp.json
│ │ ├── test-23850_cpp.json
│ │ ├── test-78769_cpp.json
│ │ ├── test-80644_cpp.json
│ │ ├── test_c.json
│ │ ├── test_cc.json
│ │ └── test_cpp.json
│ ├── csharp/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── csharp.json
│ │ ├── syntaxes/
│ │ │ └── csharp.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.cs
│ │ └── colorize-results/
│ │ └── test_cs.json
│ ├── css/
│ │ ├── .vscode/
│ │ │ └── launch.json
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── css.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-variables.css
│ │ │ └── test.css
│ │ └── colorize-results/
│ │ ├── test-variables_css.json
│ │ └── test_css.json
│ ├── css-language-features/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ ├── settings.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── client/
│ │ │ ├── src/
│ │ │ │ ├── cssMain.ts
│ │ │ │ ├── customData.ts
│ │ │ │ └── typings/
│ │ │ │ └── ref.d.ts
│ │ │ └── tsconfig.json
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── schemas/
│ │ │ └── package.schema.json
│ │ ├── server/
│ │ │ ├── .vscode/
│ │ │ │ ├── launch.json
│ │ │ │ └── tasks.json
│ │ │ ├── extension.webpack.config.js
│ │ │ ├── package.json
│ │ │ ├── src/
│ │ │ │ ├── cssServerMain.ts
│ │ │ │ ├── customData.ts
│ │ │ │ ├── languageModelCache.ts
│ │ │ │ ├── pathCompletion.ts
│ │ │ │ ├── test/
│ │ │ │ │ ├── completion.test.ts
│ │ │ │ │ └── links.test.ts
│ │ │ │ └── utils/
│ │ │ │ ├── documentContext.ts
│ │ │ │ ├── runner.ts
│ │ │ │ └── strings.ts
│ │ │ ├── test/
│ │ │ │ ├── index.js
│ │ │ │ ├── linksTestFixtures/
│ │ │ │ │ └── .gitignore
│ │ │ │ └── pathCompletionFixtures/
│ │ │ │ ├── .foo.js
│ │ │ │ ├── about/
│ │ │ │ │ ├── about.css
│ │ │ │ │ └── about.html
│ │ │ │ ├── index.html
│ │ │ │ ├── scss/
│ │ │ │ │ ├── _foo.scss
│ │ │ │ │ └── main.scss
│ │ │ │ └── src/
│ │ │ │ ├── feature.js
│ │ │ │ └── test.js
│ │ │ └── tsconfig.json
│ │ └── test/
│ │ └── mocha.opts
│ ├── debug-auto-launch/
│ │ ├── .vscodeignore
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── extension.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ └── tsconfig.json
│ ├── debug-server-ready/
│ │ ├── .vscode/
│ │ │ └── launch.json
│ │ ├── .vscodeignore
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── extension.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ └── tsconfig.json
│ ├── docker/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── docker.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── Dockerfile
│ │ └── colorize-results/
│ │ └── Dockerfile.json
│ ├── emmet/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── settings.json
│ │ ├── .vscodeignore
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── cgmanifest.json
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── abbreviationActions.ts
│ │ │ ├── balance.ts
│ │ │ ├── bufferStream.ts
│ │ │ ├── defaultCompletionProvider.ts
│ │ │ ├── editPoint.ts
│ │ │ ├── evaluateMathExpression.ts
│ │ │ ├── extension.ts
│ │ │ ├── imageSizeHelper.ts
│ │ │ ├── incrementDecrement.ts
│ │ │ ├── locateFile.ts
│ │ │ ├── matchTag.ts
│ │ │ ├── mergeLines.ts
│ │ │ ├── reflectCssValue.ts
│ │ │ ├── removeTag.ts
│ │ │ ├── selectItem.ts
│ │ │ ├── selectItemHTML.ts
│ │ │ ├── selectItemStylesheet.ts
│ │ │ ├── splitJoinTag.ts
│ │ │ ├── test/
│ │ │ │ ├── abbreviationAction.test.ts
│ │ │ │ ├── completion.test.ts
│ │ │ │ ├── cssAbbreviationAction.test.ts
│ │ │ │ ├── editPointSelectItemBalance.test.ts
│ │ │ │ ├── incrementDecrement.test.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── partialParsingStylesheet.test.ts
│ │ │ │ ├── reflectCssValue.test.ts
│ │ │ │ ├── tagActions.test.ts
│ │ │ │ ├── testUtils.ts
│ │ │ │ ├── toggleComment.test.ts
│ │ │ │ ├── updateImageSize.test.ts
│ │ │ │ └── wrapWithAbbreviation.test.ts
│ │ │ ├── toggleComment.ts
│ │ │ ├── typings/
│ │ │ │ ├── EmmetNode.d.ts
│ │ │ │ ├── emmetio__css-parser.d.ts
│ │ │ │ ├── emmetio__html-matcher.d.ts
│ │ │ │ ├── emmetio__math-expression.d.ts
│ │ │ │ ├── image-size.d.ts
│ │ │ │ └── refs.d.ts
│ │ │ ├── updateImageSize.ts
│ │ │ ├── updateTag.ts
│ │ │ └── util.ts
│ │ └── tsconfig.json
│ ├── extension-editing/
│ │ ├── .vscodeignore
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── extension.ts
│ │ │ ├── extensionLinter.ts
│ │ │ ├── packageDocumentHelper.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ └── tsconfig.json
│ ├── fsharp/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── fsharp.json
│ │ ├── syntaxes/
│ │ │ └── fsharp.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.fs
│ │ └── colorize-results/
│ │ └── test_fs.json
│ ├── git/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── build/
│ │ │ └── update-grammars.js
│ │ ├── cgmanifest.json
│ │ ├── extension.webpack.config.js
│ │ ├── languages/
│ │ │ ├── diff.language-configuration.json
│ │ │ ├── git-commit.language-configuration.json
│ │ │ ├── git-rebase.language-configuration.json
│ │ │ └── ignore.language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── api/
│ │ │ │ ├── api1.ts
│ │ │ │ ├── extension.ts
│ │ │ │ └── git.d.ts
│ │ │ ├── askpass-empty.sh
│ │ │ ├── askpass-main.ts
│ │ │ ├── askpass.sh
│ │ │ ├── askpass.ts
│ │ │ ├── autofetch.ts
│ │ │ ├── commands.ts
│ │ │ ├── contentProvider.ts
│ │ │ ├── decorationProvider.ts
│ │ │ ├── decorators.ts
│ │ │ ├── encoding.ts
│ │ │ ├── git.ts
│ │ │ ├── main.ts
│ │ │ ├── model.ts
│ │ │ ├── protocolHandler.ts
│ │ │ ├── repository.ts
│ │ │ ├── staging.ts
│ │ │ ├── statusbar.ts
│ │ │ ├── test/
│ │ │ │ └── git.test.ts
│ │ │ ├── typings/
│ │ │ │ ├── jschardet.d.ts
│ │ │ │ └── refs.d.ts
│ │ │ ├── uri.ts
│ │ │ ├── util.ts
│ │ │ └── watch.ts
│ │ ├── syntaxes/
│ │ │ ├── diff.tmLanguage.json
│ │ │ ├── git-commit.tmLanguage.json
│ │ │ ├── git-rebase.tmLanguage.json
│ │ │ └── ignore.tmLanguage.json
│ │ ├── test/
│ │ │ ├── colorize-fixtures/
│ │ │ │ ├── COMMIT_EDITMSG
│ │ │ │ ├── example.diff
│ │ │ │ └── git-rebase-todo
│ │ │ ├── colorize-results/
│ │ │ │ ├── COMMIT_EDITMSG.json
│ │ │ │ ├── example_diff.json
│ │ │ │ └── git-rebase-todo.json
│ │ │ └── mocha.opts
│ │ └── tsconfig.json
│ ├── git-ui/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── cgmanifest.json
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── main.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── go/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── go.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-13777.go
│ │ │ └── test.go
│ │ └── colorize-results/
│ │ ├── test-13777_go.json
│ │ └── test_go.json
│ ├── groovy/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── groovy.json
│ │ ├── syntaxes/
│ │ │ └── groovy.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.groovy
│ │ └── colorize-results/
│ │ └── test_groovy.json
│ ├── grunt/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── main.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── gulp/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── main.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── handlebars/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── Handlebars.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test.handlebars
│ │ │ └── test.hbs
│ │ └── colorize-results/
│ │ ├── test_handlebars.json
│ │ └── test_hbs.json
│ ├── hlsl/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── hlsl.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.hlsl
│ │ └── colorize-results/
│ │ └── test_hlsl.json
│ ├── html/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ ├── html-derivative.tmLanguage.json
│ │ │ └── html.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── 12750.html
│ │ │ ├── 13448.html
│ │ │ ├── 25920.html
│ │ │ └── test.html
│ │ └── colorize-results/
│ │ ├── 12750_html.json
│ │ ├── 13448_html.json
│ │ ├── 25920_html.json
│ │ └── test_html.json
│ ├── html-language-features/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ ├── settings.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── cgmanifest.json
│ │ ├── client/
│ │ │ ├── src/
│ │ │ │ ├── customData.ts
│ │ │ │ ├── htmlEmptyTagsShared.ts
│ │ │ │ ├── htmlMain.ts
│ │ │ │ ├── tagClosing.ts
│ │ │ │ └── typings/
│ │ │ │ └── ref.d.ts
│ │ │ └── tsconfig.json
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── schemas/
│ │ │ └── package.schema.json
│ │ └── server/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── extension.webpack.config.js
│ │ ├── lib/
│ │ │ ├── cgmanifest.json
│ │ │ └── jquery.d.ts
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── customData.ts
│ │ │ ├── htmlServerMain.ts
│ │ │ ├── languageModelCache.ts
│ │ │ ├── modes/
│ │ │ │ ├── cssMode.ts
│ │ │ │ ├── embeddedSupport.ts
│ │ │ │ ├── formatting.ts
│ │ │ │ ├── htmlFolding.ts
│ │ │ │ ├── htmlMode.ts
│ │ │ │ ├── javascriptMode.ts
│ │ │ │ ├── languageModes.ts
│ │ │ │ └── pathCompletion.ts
│ │ │ ├── test/
│ │ │ │ ├── completions.test.ts
│ │ │ │ ├── documentContext.test.ts
│ │ │ │ ├── embedded.test.ts
│ │ │ │ ├── fixtures/
│ │ │ │ │ ├── expected/
│ │ │ │ │ │ ├── 19813-4spaces.html
│ │ │ │ │ │ ├── 19813-tab.html
│ │ │ │ │ │ ├── 19813.html
│ │ │ │ │ │ └── 21634.html
│ │ │ │ │ └── inputs/
│ │ │ │ │ ├── 19813.html
│ │ │ │ │ └── 21634.html
│ │ │ │ ├── folding.test.ts
│ │ │ │ ├── formatting.test.ts
│ │ │ │ ├── pathCompletionFixtures/
│ │ │ │ │ ├── .foo.js
│ │ │ │ │ ├── about/
│ │ │ │ │ │ ├── about.css
│ │ │ │ │ │ ├── about.html
│ │ │ │ │ │ └── media/
│ │ │ │ │ │ └── icon.pic
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── src/
│ │ │ │ │ ├── feature.js
│ │ │ │ │ └── test.js
│ │ │ │ └── words.test.ts
│ │ │ └── utils/
│ │ │ ├── arrays.ts
│ │ │ ├── documentContext.ts
│ │ │ ├── runner.ts
│ │ │ └── strings.ts
│ │ ├── test/
│ │ │ └── index.js
│ │ └── tsconfig.json
│ ├── image-preview/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── media/
│ │ │ ├── main.css
│ │ │ └── main.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── dispose.ts
│ │ │ ├── extension.ts
│ │ │ ├── preview.ts
│ │ │ ├── sizeStatusBarEntry.ts
│ │ │ ├── typings/
│ │ │ │ └── ref.d.ts
│ │ │ └── zoomStatusBarEntry.ts
│ │ └── tsconfig.json
│ ├── ini/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── ini.language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── properties.language-configuration.json
│ │ ├── syntaxes/
│ │ │ └── ini.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.ini
│ │ └── colorize-results/
│ │ └── test_ini.json
│ ├── jake/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── main.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── java/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── java.snippets.json
│ │ ├── syntaxes/
│ │ │ └── java.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── basic.java
│ │ └── colorize-results/
│ │ └── basic_java.json
│ ├── javascript/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── javascript-language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── javascript.json
│ │ ├── syntaxes/
│ │ │ ├── JavaScript.tmLanguage.json
│ │ │ ├── JavaScriptReact.tmLanguage.json
│ │ │ ├── Readme.md
│ │ │ └── Regular Expressions (JavaScript).tmLanguage
│ │ ├── tags-language-configuration.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test.js
│ │ │ ├── test.jsx
│ │ │ └── test6916.js
│ │ └── colorize-results/
│ │ ├── test6916_js.json
│ │ ├── test_js.json
│ │ └── test_jsx.json
│ ├── json/
│ │ ├── .vscodeignore
│ │ ├── build/
│ │ │ └── update-grammars.js
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ ├── JSON.tmLanguage.json
│ │ │ └── JSONC.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.json
│ │ └── colorize-results/
│ │ └── test_json.json
│ ├── json-language-features/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── CONTRIBUTING.md
│ │ ├── README.md
│ │ ├── client/
│ │ │ ├── src/
│ │ │ │ ├── jsonMain.ts
│ │ │ │ ├── typings/
│ │ │ │ │ └── ref.d.ts
│ │ │ │ └── utils/
│ │ │ │ └── hash.ts
│ │ │ └── tsconfig.json
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── server/
│ │ ├── .npmignore
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── README.md
│ │ ├── bin/
│ │ │ └── vscode-json-languageserver
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── jsonServerMain.ts
│ │ │ ├── languageModelCache.ts
│ │ │ └── utils/
│ │ │ ├── runner.ts
│ │ │ └── strings.ts
│ │ ├── test/
│ │ │ └── mocha.opts
│ │ └── tsconfig.json
│ ├── less/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── less.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── 14119.less
│ │ │ ├── test-cssvariables.less
│ │ │ └── test.less
│ │ └── colorize-results/
│ │ ├── 14119_less.json
│ │ ├── test-cssvariables_less.json
│ │ └── test_less.json
│ ├── log/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── log.tmLanguage.json
│ │ └── test/
│ │ └── colorize-results/
│ │ └── test_log.json
│ ├── lua/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── lua.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.lua
│ │ └── colorize-results/
│ │ └── test_lua.json
│ ├── make/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── make.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── makefile
│ │ └── colorize-results/
│ │ └── makefile.json
│ ├── markdown-basics/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── markdown.json
│ │ ├── syntaxes/
│ │ │ └── markdown.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-33886.md
│ │ │ └── test.md
│ │ └── colorize-results/
│ │ ├── test-33886_md.json
│ │ └── test_md.json
│ ├── markdown-language-features/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── media/
│ │ │ ├── highlight.css
│ │ │ ├── index.js
│ │ │ ├── markdown.css
│ │ │ └── pre.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── preview-src/
│ │ │ ├── activeLineMarker.ts
│ │ │ ├── csp.ts
│ │ │ ├── events.ts
│ │ │ ├── index.ts
│ │ │ ├── loading.ts
│ │ │ ├── messaging.ts
│ │ │ ├── pre.ts
│ │ │ ├── scroll-sync.ts
│ │ │ ├── settings.ts
│ │ │ ├── strings.ts
│ │ │ └── tsconfig.json
│ │ ├── schemas/
│ │ │ └── package.schema.json
│ │ ├── src/
│ │ │ ├── commandManager.ts
│ │ │ ├── commands/
│ │ │ │ ├── index.ts
│ │ │ │ ├── moveCursorToPosition.ts
│ │ │ │ ├── openDocumentLink.ts
│ │ │ │ ├── refreshPreview.ts
│ │ │ │ ├── renderDocument.ts
│ │ │ │ ├── showPreview.ts
│ │ │ │ ├── showPreviewSecuritySelector.ts
│ │ │ │ ├── showSource.ts
│ │ │ │ └── toggleLock.ts
│ │ │ ├── extension.ts
│ │ │ ├── features/
│ │ │ │ ├── documentLinkProvider.ts
│ │ │ │ ├── documentSymbolProvider.ts
│ │ │ │ ├── foldingProvider.ts
│ │ │ │ ├── preview.ts
│ │ │ │ ├── previewConfig.ts
│ │ │ │ ├── previewContentProvider.ts
│ │ │ │ ├── previewManager.ts
│ │ │ │ └── workspaceSymbolProvider.ts
│ │ │ ├── logger.ts
│ │ │ ├── markdownEngine.ts
│ │ │ ├── markdownExtensions.ts
│ │ │ ├── security.ts
│ │ │ ├── slugify.ts
│ │ │ ├── tableOfContentsProvider.ts
│ │ │ ├── telemetryReporter.ts
│ │ │ ├── test/
│ │ │ │ ├── documentLinkProvider.test.ts
│ │ │ │ ├── documentSymbolProvider.test.ts
│ │ │ │ ├── engine.test.ts
│ │ │ │ ├── engine.ts
│ │ │ │ ├── foldingProvider.test.ts
│ │ │ │ ├── inMemoryDocument.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── tableOfContentsProvider.test.ts
│ │ │ │ └── workspaceSymbolProvider.test.ts
│ │ │ ├── typings/
│ │ │ │ └── ref.d.ts
│ │ │ └── util/
│ │ │ ├── arrays.ts
│ │ │ ├── dispose.ts
│ │ │ ├── file.ts
│ │ │ ├── lazy.ts
│ │ │ ├── links.ts
│ │ │ ├── resources.ts
│ │ │ └── topmostLineMonitor.ts
│ │ ├── tsconfig.json
│ │ └── webpack.config.js
│ ├── merge-conflict/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── codelensProvider.ts
│ │ │ ├── commandHandler.ts
│ │ │ ├── contentProvider.ts
│ │ │ ├── delayer.ts
│ │ │ ├── documentMergeConflict.ts
│ │ │ ├── documentTracker.ts
│ │ │ ├── extension.ts
│ │ │ ├── interfaces.ts
│ │ │ ├── mergeConflictParser.ts
│ │ │ ├── mergeDecorator.ts
│ │ │ ├── services.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── npm/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── commands.ts
│ │ │ ├── features/
│ │ │ │ ├── bowerJSONContribution.ts
│ │ │ │ ├── jsonContributions.ts
│ │ │ │ ├── markedTextUtil.ts
│ │ │ │ └── packageJSONContribution.ts
│ │ │ ├── main.ts
│ │ │ ├── npmView.ts
│ │ │ ├── scriptHover.ts
│ │ │ ├── tasks.ts
│ │ │ └── typings/
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── objective-c/
│ │ ├── .vscodeignore
│ │ ├── build/
│ │ │ └── update-grammars.js
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ ├── objective-c++.tmLanguage.json
│ │ │ └── objective-c.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test.m
│ │ │ └── test.mm
│ │ └── colorize-results/
│ │ ├── test_m.json
│ │ └── test_mm.json
│ ├── package.json
│ ├── perl/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── perl.language-configuration.json
│ │ ├── perl6.language-configuration.json
│ │ ├── syntaxes/
│ │ │ ├── perl.tmLanguage.json
│ │ │ └── perl6.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test.pl
│ │ │ └── test2.pl
│ │ └── colorize-results/
│ │ ├── test2_pl.json
│ │ └── test_pl.json
│ ├── php/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── build/
│ │ │ └── update-grammar.js
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── php.snippets.json
│ │ ├── syntaxes/
│ │ │ ├── html.tmLanguage.json
│ │ │ └── php.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── issue-28354.php
│ │ │ ├── issue-76997.php
│ │ │ └── test.php
│ │ └── colorize-results/
│ │ ├── issue-28354_php.json
│ │ ├── issue-76997_php.json
│ │ └── test_php.json
│ ├── php-language-features/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── extension.webpack.config.js
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── features/
│ │ │ │ ├── completionItemProvider.ts
│ │ │ │ ├── hoverProvider.ts
│ │ │ │ ├── phpGlobalFunctions.ts
│ │ │ │ ├── phpGlobals.ts
│ │ │ │ ├── signatureHelpProvider.ts
│ │ │ │ ├── utils/
│ │ │ │ │ ├── async.ts
│ │ │ │ │ └── markedTextUtil.ts
│ │ │ │ └── validationProvider.ts
│ │ │ ├── phpMain.ts
│ │ │ └── typings/
│ │ │ ├── node.additions.d.ts
│ │ │ └── refs.d.ts
│ │ └── tsconfig.json
│ ├── postinstall.js
│ ├── powershell/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── powershell.json
│ │ ├── syntaxes/
│ │ │ └── powershell.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-freeze-56476.ps1
│ │ │ └── test.ps1
│ │ └── colorize-results/
│ │ ├── test-freeze-56476_ps1.json
│ │ └── test_ps1.json
│ ├── pug/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── pug.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-4287.pug
│ │ │ └── test.pug
│ │ └── colorize-results/
│ │ ├── test-4287_pug.json
│ │ └── test_pug.json
│ ├── python/
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── extension.webpack.config.js
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── src/
│ │ │ ├── pythonMain.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ ├── syntaxes/
│ │ │ ├── MagicPython.tmLanguage.json
│ │ │ └── MagicRegExp.tmLanguage.json
│ │ ├── test/
│ │ │ ├── colorize-fixtures/
│ │ │ │ ├── test-freeze-56377.py
│ │ │ │ └── test.py
│ │ │ └── colorize-results/
│ │ │ ├── test-freeze-56377_py.json
│ │ │ └── test_py.json
│ │ └── tsconfig.json
│ ├── r/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── r.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.r
│ │ └── colorize-results/
│ │ └── test_r.json
│ ├── razor/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── cshtml.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.cshtml
│ │ └── colorize-results/
│ │ └── test_cshtml.json
│ ├── ruby/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── ruby.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.rb
│ │ └── colorize-results/
│ │ └── test_rb.json
│ ├── rust/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── rust.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-6611.rs
│ │ │ └── test.rs
│ │ └── colorize-results/
│ │ ├── test-6611_rs.json
│ │ └── test_rs.json
│ ├── scss/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ ├── sassdoc.tmLanguage.json
│ │ │ └── scss.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-cssvariables.scss
│ │ │ └── test.scss
│ │ └── colorize-results/
│ │ ├── test-cssvariables_scss.json
│ │ └── test_scss.json
│ ├── shaderlab/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── shaderlab.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.shader
│ │ └── colorize-results/
│ │ └── test_shader.json
│ ├── shared.tsconfig.json
│ ├── shared.webpack.config.js
│ ├── shellscript/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── shell-unix-bash.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.sh
│ │ └── colorize-results/
│ │ └── test_sh.json
│ ├── sql/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ └── sql.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.sql
│ │ └── colorize-results/
│ │ └── test_sql.json
│ ├── swift/
│ │ ├── .vscodeignore
│ │ ├── LICENSE.md
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── swift.json
│ │ ├── syntaxes/
│ │ │ └── swift.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.swift
│ │ └── colorize-results/
│ │ └── test_swift.json
│ ├── theme-abyss/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── abyss-color-theme.json
│ ├── theme-defaults/
│ │ ├── fileicons/
│ │ │ └── vs_minimal-icon-theme.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ ├── dark_defaults.json
│ │ ├── dark_plus.json
│ │ ├── dark_vs.json
│ │ ├── hc_black.json
│ │ ├── hc_black_defaults.json
│ │ ├── light_defaults.json
│ │ ├── light_plus.json
│ │ └── light_vs.json
│ ├── theme-kimbie-dark/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── kimbie-dark-color-theme.json
│ ├── theme-monokai/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── monokai-color-theme.json
│ ├── theme-monokai-dimmed/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── dimmed-monokai-color-theme.json
│ ├── theme-quietlight/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── quietlight-color-theme.json
│ ├── theme-red/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── Red-color-theme.json
│ ├── theme-seti/
│ │ ├── .vscodeignore
│ │ ├── ThirdPartyNotices.txt
│ │ ├── build/
│ │ │ └── update-icon-theme.js
│ │ ├── cgmanifest.json
│ │ ├── icons/
│ │ │ └── vs-seti-icon-theme.json
│ │ ├── package.json
│ │ └── package.nls.json
│ ├── theme-solarized-dark/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── solarized-dark-color-theme.json
│ ├── theme-solarized-light/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── solarized-light-color-theme.json
│ ├── theme-tomorrow-night-blue/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ └── themes/
│ │ └── tomorrow-night-blue-theme.json
│ ├── typescript-basics/
│ │ ├── .vscodeignore
│ │ ├── build/
│ │ │ └── update-grammars.js
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── typescript.json
│ │ ├── syntaxes/
│ │ │ ├── Readme.md
│ │ │ ├── TypeScript.tmLanguage.json
│ │ │ ├── TypeScriptReact.tmLanguage.json
│ │ │ └── jsdoc.injection.tmLanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ ├── test-brackets.tsx
│ │ │ ├── test-function-inv.ts
│ │ │ ├── test-issue11.ts
│ │ │ ├── test-issue5431.ts
│ │ │ ├── test-issue5465.ts
│ │ │ ├── test-issue5566.ts
│ │ │ ├── test-jsdoc-example.ts
│ │ │ ├── test-jsdoc-markdown.ts
│ │ │ ├── test-jsdoc-multiline-type.ts
│ │ │ ├── test-keywords.ts
│ │ │ ├── test-members.ts
│ │ │ ├── test-object-literals.ts
│ │ │ ├── test-strings.ts
│ │ │ ├── test-this.ts
│ │ │ ├── test.ts
│ │ │ └── tsconfig_off.json
│ │ └── colorize-results/
│ │ ├── test-brackets_tsx.json
│ │ ├── test-function-inv_ts.json
│ │ ├── test-issue11_ts.json
│ │ ├── test-issue5431_ts.json
│ │ ├── test-issue5465_ts.json
│ │ ├── test-issue5566_ts.json
│ │ ├── test-jsdoc-example_ts.json
│ │ ├── test-jsdoc-markdown_ts.json
│ │ ├── test-jsdoc-multiline-type_ts.json
│ │ ├── test-keywords_ts.json
│ │ ├── test-members_ts.json
│ │ ├── test-object-literals_ts.json
│ │ ├── test-strings_ts.json
│ │ ├── test-this_ts.json
│ │ ├── test_ts.json
│ │ └── tsconfig_off_json.json
│ ├── typescript-language-features/
│ │ ├── .vscodeignore
│ │ ├── README.md
│ │ ├── cgmanifest.json
│ │ ├── extension.webpack.config.js
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── schemas/
│ │ │ ├── jsconfig.schema.json
│ │ │ ├── package.schema.json
│ │ │ └── tsconfig.schema.json
│ │ ├── src/
│ │ │ ├── api.ts
│ │ │ ├── commands/
│ │ │ │ ├── configurePlugin.ts
│ │ │ │ ├── goToProjectConfiguration.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── openTsServerLog.ts
│ │ │ │ ├── reloadProject.ts
│ │ │ │ ├── restartTsServer.ts
│ │ │ │ └── selectTypeScriptVersion.ts
│ │ │ ├── extension.ts
│ │ │ ├── features/
│ │ │ │ ├── baseCodeLensProvider.ts
│ │ │ │ ├── bufferSyncSupport.ts
│ │ │ │ ├── completions.ts
│ │ │ │ ├── definitionProviderBase.ts
│ │ │ │ ├── definitions.ts
│ │ │ │ ├── diagnostics.ts
│ │ │ │ ├── directiveCommentCompletions.ts
│ │ │ │ ├── documentHighlight.ts
│ │ │ │ ├── documentSymbol.ts
│ │ │ │ ├── fileConfigurationManager.ts
│ │ │ │ ├── fixAll.ts
│ │ │ │ ├── folding.ts
│ │ │ │ ├── formatting.ts
│ │ │ │ ├── hover.ts
│ │ │ │ ├── implementations.ts
│ │ │ │ ├── implementationsCodeLens.ts
│ │ │ │ ├── jsDocCompletions.ts
│ │ │ │ ├── languageConfiguration.ts
│ │ │ │ ├── organizeImports.ts
│ │ │ │ ├── quickFix.ts
│ │ │ │ ├── refactor.ts
│ │ │ │ ├── references.ts
│ │ │ │ ├── referencesCodeLens.ts
│ │ │ │ ├── rename.ts
│ │ │ │ ├── signatureHelp.ts
│ │ │ │ ├── smartSelect.ts
│ │ │ │ ├── tagClosing.ts
│ │ │ │ ├── task.ts
│ │ │ │ ├── tsconfig.ts
│ │ │ │ ├── typeDefinitions.ts
│ │ │ │ ├── updatePathsOnRename.ts
│ │ │ │ └── workspaceSymbols.ts
│ │ │ ├── languageProvider.ts
│ │ │ ├── protocol.const.ts
│ │ │ ├── protocol.d.ts
│ │ │ ├── test/
│ │ │ │ ├── cachedResponse.test.ts
│ │ │ │ ├── completions.test.ts
│ │ │ │ ├── functionCallSnippet.test.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── jsdocSnippet.test.ts
│ │ │ │ ├── onEnter.test.ts
│ │ │ │ ├── previewer.test.ts
│ │ │ │ ├── requestQueue.test.ts
│ │ │ │ ├── server.test.ts
│ │ │ │ └── testUtils.ts
│ │ │ ├── tsServer/
│ │ │ │ ├── cachedResponse.ts
│ │ │ │ ├── callbackMap.ts
│ │ │ │ ├── requestQueue.ts
│ │ │ │ ├── server.ts
│ │ │ │ ├── serverError.ts
│ │ │ │ └── spawner.ts
│ │ │ ├── typeScriptServiceClientHost.ts
│ │ │ ├── typescriptService.ts
│ │ │ ├── typescriptServiceClient.ts
│ │ │ ├── typings/
│ │ │ │ ├── collections.d.ts
│ │ │ │ └── ref.d.ts
│ │ │ └── utils/
│ │ │ ├── api.ts
│ │ │ ├── arrays.ts
│ │ │ ├── async.ts
│ │ │ ├── cancellation.ts
│ │ │ ├── codeAction.ts
│ │ │ ├── commandManager.ts
│ │ │ ├── configuration.ts
│ │ │ ├── dependentRegistration.ts
│ │ │ ├── dispose.ts
│ │ │ ├── electron.ts
│ │ │ ├── fileSchemes.ts
│ │ │ ├── languageDescription.ts
│ │ │ ├── languageModeIds.ts
│ │ │ ├── lazy.ts
│ │ │ ├── logDirectoryProvider.ts
│ │ │ ├── logger.ts
│ │ │ ├── managedFileContext.ts
│ │ │ ├── memoize.ts
│ │ │ ├── pluginPathsProvider.ts
│ │ │ ├── plugins.ts
│ │ │ ├── previewer.ts
│ │ │ ├── projectStatus.ts
│ │ │ ├── regexp.ts
│ │ │ ├── relativePathResolver.ts
│ │ │ ├── resourceMap.ts
│ │ │ ├── snippetForFunctionCall.ts
│ │ │ ├── surveyor.ts
│ │ │ ├── telemetry.ts
│ │ │ ├── temp.ts
│ │ │ ├── tracer.ts
│ │ │ ├── tsconfig.ts
│ │ │ ├── tsconfigProvider.ts
│ │ │ ├── typeConverters.ts
│ │ │ ├── typingsStatus.ts
│ │ │ ├── versionPicker.ts
│ │ │ ├── versionProvider.ts
│ │ │ ├── versionStatus.ts
│ │ │ └── wireProtocol.ts
│ │ └── tsconfig.json
│ ├── vb/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── language-configuration.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── snippets/
│ │ │ └── vb.json
│ │ ├── syntaxes/
│ │ │ └── asp-vb-net.tmlanguage.json
│ │ └── test/
│ │ ├── colorize-fixtures/
│ │ │ └── test.vb
│ │ └── colorize-results/
│ │ └── test_vb.json
│ ├── vscode-api-tests/
│ │ ├── .gitignore
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── .vscodeignore
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── extension.ts
│ │ │ ├── memfs.ts
│ │ │ ├── singlefolder-tests/
│ │ │ │ ├── commands.test.ts
│ │ │ │ ├── configuration.test.ts
│ │ │ │ ├── editor.test.ts
│ │ │ │ ├── env.test.ts
│ │ │ │ ├── index.ts
│ │ │ │ ├── languages.test.ts
│ │ │ │ ├── quickInput.test.ts
│ │ │ │ ├── terminal.test.ts
│ │ │ │ ├── types.test.ts
│ │ │ │ ├── webview.test.ts
│ │ │ │ ├── window.test.ts
│ │ │ │ ├── workspace.fs.test.ts
│ │ │ │ ├── workspace.tasks.test.ts
│ │ │ │ └── workspace.test.ts
│ │ │ ├── typings/
│ │ │ │ └── ref.d.ts
│ │ │ ├── utils.ts
│ │ │ └── workspace-tests/
│ │ │ ├── index.ts
│ │ │ └── workspace.test.ts
│ │ ├── testWorkspace/
│ │ │ ├── .vscode/
│ │ │ │ └── settings.json
│ │ │ ├── 10linefile.ts
│ │ │ ├── 30linefile.ts
│ │ │ ├── bower.json
│ │ │ ├── far.js
│ │ │ ├── files-exclude/
│ │ │ │ └── file.txt
│ │ │ ├── search-exclude/
│ │ │ │ └── file.txt
│ │ │ └── simple.txt
│ │ ├── testWorkspace2/
│ │ │ └── simple.txt
│ │ ├── testworkspace.code-workspace
│ │ └── tsconfig.json
│ ├── vscode-colorize-tests/
│ │ ├── .gitignore
│ │ ├── .vscode/
│ │ │ ├── launch.json
│ │ │ └── tasks.json
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── colorizer.test.ts
│ │ │ ├── index.ts
│ │ │ └── typings/
│ │ │ └── ref.d.ts
│ │ └── tsconfig.json
│ ├── vscode-test-resolver/
│ │ ├── .gitignore
│ │ ├── .vscode/
│ │ │ └── launch.json
│ │ ├── .vscodeignore
│ │ ├── package.json
│ │ ├── scripts/
│ │ │ └── terminateProcess.sh
│ │ ├── src/
│ │ │ ├── download.ts
│ │ │ ├── extension.ts
│ │ │ ├── typings/
│ │ │ │ └── ref.d.ts
│ │ │ └── util/
│ │ │ └── processes.ts
│ │ └── tsconfig.json
│ ├── xml/
│ │ ├── .vscodeignore
│ │ ├── cgmanifest.json
│ │ ├── package.json
│ │ ├── package.nls.json
│ │ ├── syntaxes/
│ │ │ ├── xml.tmLanguage.json
│ │ │ └── xsl.tmLanguage.json
│ │ ├── test/
│ │ │ ├── colorize-fixtures/
│ │ │ │ ├── test-7115.xml
│ │ │ │ └── test.xml
│ │ │ └── colorize-results/
│ │ │ ├── test-7115_xml.json
│ │ │ └── test_xml.json
│ │ ├── xml.language-configuration.json
│ │ └── xsl.language-configuration.json
│ └── yaml/
│ ├── .vscodeignore
│ ├── cgmanifest.json
│ ├── language-configuration.json
│ ├── package.json
│ ├── package.nls.json
│ ├── syntaxes/
│ │ └── yaml.tmLanguage.json
│ └── test/
│ ├── colorize-fixtures/
│ │ ├── issue-1550.yaml
│ │ ├── issue-4008.yaml
│ │ ├── issue-6303.yaml
│ │ └── test.yaml
│ └── colorize-results/
│ ├── issue-1550_yaml.json
│ ├── issue-4008_yaml.json
│ ├── issue-6303_yaml.json
│ └── test_yaml.json
├── gulpfile.js
├── package.json
├── product.json
├── remote/
│ ├── .yarnrc
│ ├── package.json
│ └── web/
│ └── package.json
├── resources/
│ ├── completions/
│ │ ├── bash/
│ │ │ └── code
│ │ └── zsh/
│ │ └── _code
│ ├── darwin/
│ │ ├── bat.icns
│ │ ├── bin/
│ │ │ └── code.sh
│ │ ├── bower.icns
│ │ ├── c.icns
│ │ ├── code.icns
│ │ ├── config.icns
│ │ ├── cpp.icns
│ │ ├── csharp.icns
│ │ ├── css.icns
│ │ ├── default.icns
│ │ ├── go.icns
│ │ ├── html.icns
│ │ ├── jade.icns
│ │ ├── java.icns
│ │ ├── javascript.icns
│ │ ├── json.icns
│ │ ├── less.icns
│ │ ├── markdown.icns
│ │ ├── php.icns
│ │ ├── powershell.icns
│ │ ├── python.icns
│ │ ├── react.icns
│ │ ├── ruby.icns
│ │ ├── sass.icns
│ │ ├── shell.icns
│ │ ├── sql.icns
│ │ ├── typescript.icns
│ │ ├── vue.icns
│ │ ├── xml.icns
│ │ └── yaml.icns
│ ├── linux/
│ │ ├── bin/
│ │ │ └── code.sh
│ │ ├── code-url-handler.desktop
│ │ ├── code.appdata.xml
│ │ ├── code.desktop
│ │ ├── debian/
│ │ │ ├── control.template
│ │ │ ├── postinst.template
│ │ │ ├── postrm.template
│ │ │ └── prerm.template
│ │ ├── rpm/
│ │ │ ├── code.spec.template
│ │ │ ├── code.xpm
│ │ │ └── dependencies.json
│ │ └── snap/
│ │ ├── electron-launch
│ │ └── snapcraft.yaml
│ └── win32/
│ ├── VisualElementsManifest.xml
│ └── bin/
│ ├── code.cmd
│ └── code.sh
├── scripts/
│ ├── code-cli.bat
│ ├── code-cli.sh
│ ├── code-web.js
│ ├── code.bat
│ ├── code.sh
│ ├── generate-definitelytyped.sh
│ ├── node-electron.bat
│ ├── node-electron.sh
│ ├── npm.bat
│ ├── npm.sh
│ ├── test-documentation.bat
│ ├── test-documentation.sh
│ ├── test-integration.bat
│ ├── test-integration.sh
│ ├── test.bat
│ └── test.sh
├── src/
│ ├── .eslintrc
│ ├── bootstrap-amd.js
│ ├── bootstrap-fork.js
│ ├── bootstrap-window.js
│ ├── bootstrap.js
│ ├── buildfile.js
│ ├── cli.js
│ ├── main.js
│ ├── paths.js
│ ├── placeholder.ts
│ ├── tsconfig.base.json
│ ├── tsconfig.json
│ ├── tsconfig.monaco.json
│ ├── typings/
│ │ ├── applicationInsights.d.ts
│ │ ├── applicationinsights-web.d.ts
│ │ ├── buffer-crc32.d.ts
│ │ ├── caseless.d.ts
│ │ ├── cgmanifest.json
│ │ ├── chokidar.d.ts
│ │ ├── decompress.d.ts
│ │ ├── electron-store.d.ts
│ │ ├── electron.d.ts
│ │ ├── es2015-proxy.d.ts
│ │ ├── es6-promise.d.ts
│ │ ├── fast-glob.d.ts
│ │ ├── form-data.d.ts
│ │ ├── github.d.ts
│ │ ├── graceful-fs.d.ts
│ │ ├── http-proxy-agent.d.ts
│ │ ├── https-proxy-agent.d.ts
│ │ ├── iconv-lite.d.ts
│ │ ├── jschardet.d.ts
│ │ ├── jszip.d.ts
│ │ ├── lib.array-ext.d.ts
│ │ ├── lib.es2018.promise.d.ts
│ │ ├── lib.ie11-unsafe.d.ts
│ │ ├── lib.webworker.importscripts.d.ts
│ │ ├── native-is-elevated.d.ts
│ │ ├── native-keymap.d.ts
│ │ ├── native-watchdog.d.ts
│ │ ├── node-pty.d.ts
│ │ ├── node.processEnv-ext.d.ts
│ │ ├── nsfw.d.ts
│ │ ├── onigasm-umd.d.ts
│ │ ├── proper-lockfile.d.ts
│ │ ├── request-progress.d.ts
│ │ ├── request-progress.stat.d.ts
│ │ ├── request.d.ts
│ │ ├── require-monaco.d.ts
│ │ ├── require.d.ts
│ │ ├── semver-umd.d.ts
│ │ ├── serialport.d.ts
│ │ ├── spdlog.d.ts
│ │ ├── split2.d.ts
│ │ ├── sudo-prompt.d.ts
│ │ ├── thenable.d.ts
│ │ ├── tough-cookie.d.ts
│ │ ├── url-exists.d.ts
│ │ ├── uuid.d.ts
│ │ ├── v8-inspect-profiler.d.ts
│ │ ├── vscode-minimist.d.ts
│ │ ├── vscode-proxy-agent.d.ts
│ │ ├── vscode-ripgrep.d.ts
│ │ ├── vscode-sqlite3.d.ts
│ │ ├── vscode-textmate.d.ts
│ │ ├── vscode-windows-ca-certs.d.ts
│ │ ├── vscode-windows-registry.d.ts
│ │ ├── vsda.d.ts
│ │ ├── windows-foreground-love.d.ts
│ │ ├── windows-mutex.d.ts
│ │ ├── windows-process-tree.d.ts
│ │ ├── windows-shortcuts.d.ts
│ │ ├── xterm-addon-search.d.ts
│ │ ├── xterm-addon-web-links.d.ts
│ │ ├── xterm.d.ts
│ │ ├── yauzl.d.ts
│ │ └── yazl.d.ts
│ └── vs/
│ ├── base/
│ │ ├── browser/
│ │ │ ├── browser.ts
│ │ │ ├── contextmenu.ts
│ │ │ ├── dnd.ts
│ │ │ ├── dom.ts
│ │ │ ├── event.ts
│ │ │ ├── fastDomNode.ts
│ │ │ ├── formattedTextRenderer.ts
│ │ │ ├── globalMouseMoveMonitor.ts
│ │ │ ├── history.ts
│ │ │ ├── iframe.ts
│ │ │ ├── keyboardEvent.ts
│ │ │ ├── markdownRenderer.ts
│ │ │ ├── mouseEvent.ts
│ │ │ ├── touch.ts
│ │ │ └── ui/
│ │ │ ├── actionbar/
│ │ │ │ ├── actionbar.css
│ │ │ │ └── actionbar.ts
│ │ │ ├── aria/
│ │ │ │ ├── aria.css
│ │ │ │ └── aria.ts
│ │ │ ├── breadcrumbs/
│ │ │ │ ├── breadcrumbsWidget.css
│ │ │ │ └── breadcrumbsWidget.ts
│ │ │ ├── button/
│ │ │ │ ├── button.css
│ │ │ │ └── button.ts
│ │ │ ├── centered/
│ │ │ │ └── centeredViewLayout.ts
│ │ │ ├── checkbox/
│ │ │ │ ├── checkbox.css
│ │ │ │ └── checkbox.ts
│ │ │ ├── codiconLabel/
│ │ │ │ ├── codicon/
│ │ │ │ │ ├── codicon-animations.css
│ │ │ │ │ └── codicon.css
│ │ │ │ └── codiconLabel.ts
│ │ │ ├── contextview/
│ │ │ │ ├── contextview.css
│ │ │ │ └── contextview.ts
│ │ │ ├── countBadge/
│ │ │ │ ├── countBadge.css
│ │ │ │ └── countBadge.ts
│ │ │ ├── dialog/
│ │ │ │ ├── dialog.css
│ │ │ │ └── dialog.ts
│ │ │ ├── dropdown/
│ │ │ │ ├── dropdown.css
│ │ │ │ └── dropdown.ts
│ │ │ ├── findinput/
│ │ │ │ ├── findInput.css
│ │ │ │ ├── findInput.ts
│ │ │ │ ├── findInputCheckboxes.ts
│ │ │ │ └── replaceInput.ts
│ │ │ ├── grid/
│ │ │ │ ├── grid.ts
│ │ │ │ ├── gridview.css
│ │ │ │ └── gridview.ts
│ │ │ ├── highlightedlabel/
│ │ │ │ └── highlightedLabel.ts
│ │ │ ├── iconLabel/
│ │ │ │ ├── iconLabel.ts
│ │ │ │ └── iconlabel.css
│ │ │ ├── inputbox/
│ │ │ │ ├── inputBox.css
│ │ │ │ └── inputBox.ts
│ │ │ ├── keybindingLabel/
│ │ │ │ ├── keybindingLabel.css
│ │ │ │ └── keybindingLabel.ts
│ │ │ ├── list/
│ │ │ │ ├── list.css
│ │ │ │ ├── list.ts
│ │ │ │ ├── listPaging.ts
│ │ │ │ ├── listView.ts
│ │ │ │ ├── listWidget.ts
│ │ │ │ ├── rangeMap.ts
│ │ │ │ ├── rowCache.ts
│ │ │ │ └── splice.ts
│ │ │ ├── menu/
│ │ │ │ ├── menu.css
│ │ │ │ ├── menu.ts
│ │ │ │ └── menubar.ts
│ │ │ ├── octiconLabel/
│ │ │ │ ├── octiconLabel.mock.ts
│ │ │ │ ├── octiconLabel.ts
│ │ │ │ └── octicons/
│ │ │ │ ├── octicons-animations.css
│ │ │ │ └── octicons.css
│ │ │ ├── progressbar/
│ │ │ │ ├── progressbar.css
│ │ │ │ └── progressbar.ts
│ │ │ ├── sash/
│ │ │ │ ├── sash.css
│ │ │ │ └── sash.ts
│ │ │ ├── scrollbar/
│ │ │ │ ├── abstractScrollbar.ts
│ │ │ │ ├── horizontalScrollbar.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── scrollbars.css
│ │ │ │ ├── scrollableElement.ts
│ │ │ │ ├── scrollableElementOptions.ts
│ │ │ │ ├── scrollbarArrow.ts
│ │ │ │ ├── scrollbarState.ts
│ │ │ │ ├── scrollbarVisibilityController.ts
│ │ │ │ └── verticalScrollbar.ts
│ │ │ ├── selectBox/
│ │ │ │ ├── selectBox.css
│ │ │ │ ├── selectBox.ts
│ │ │ │ ├── selectBoxCustom.css
│ │ │ │ ├── selectBoxCustom.ts
│ │ │ │ └── selectBoxNative.ts
│ │ │ ├── splitview/
│ │ │ │ ├── panelview.css
│ │ │ │ ├── panelview.ts
│ │ │ │ ├── splitview.css
│ │ │ │ └── splitview.ts
│ │ │ ├── toolbar/
│ │ │ │ ├── toolbar.css
│ │ │ │ └── toolbar.ts
│ │ │ ├── tree/
│ │ │ │ ├── abstractTree.ts
│ │ │ │ ├── asyncDataTree.ts
│ │ │ │ ├── compressedObjectTreeModel.ts
│ │ │ │ ├── dataTree.ts
│ │ │ │ ├── indexTree.ts
│ │ │ │ ├── indexTreeModel.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── panelviewlet.css
│ │ │ │ │ └── tree.css
│ │ │ │ ├── objectTree.ts
│ │ │ │ ├── objectTreeModel.ts
│ │ │ │ ├── tree.ts
│ │ │ │ └── treeDefaults.ts
│ │ │ └── widget.ts
│ │ ├── common/
│ │ │ ├── actions.ts
│ │ │ ├── amd.ts
│ │ │ ├── arrays.ts
│ │ │ ├── assert.ts
│ │ │ ├── async.ts
│ │ │ ├── buffer.ts
│ │ │ ├── buildunit.json
│ │ │ ├── cache.ts
│ │ │ ├── cancellation.ts
│ │ │ ├── charCode.ts
│ │ │ ├── collections.ts
│ │ │ ├── color.ts
│ │ │ ├── comparers.ts
│ │ │ ├── console.ts
│ │ │ ├── date.ts
│ │ │ ├── decorators.ts
│ │ │ ├── diff/
│ │ │ │ ├── diff.ts
│ │ │ │ └── diffChange.ts
│ │ │ ├── errorMessage.ts
│ │ │ ├── errors.ts
│ │ │ ├── errorsWithActions.ts
│ │ │ ├── event.ts
│ │ │ ├── extpath.ts
│ │ │ ├── filters.ts
│ │ │ ├── functional.ts
│ │ │ ├── glob.ts
│ │ │ ├── hash.ts
│ │ │ ├── history.ts
│ │ │ ├── htmlContent.ts
│ │ │ ├── idGenerator.ts
│ │ │ ├── insane/
│ │ │ │ ├── cgmanifest.json
│ │ │ │ ├── insane.d.ts
│ │ │ │ ├── insane.js
│ │ │ │ └── insane.license.txt
│ │ │ ├── iterator.ts
│ │ │ ├── json.ts
│ │ │ ├── jsonEdit.ts
│ │ │ ├── jsonErrorMessages.ts
│ │ │ ├── jsonFormatter.ts
│ │ │ ├── jsonSchema.ts
│ │ │ ├── keyCodes.ts
│ │ │ ├── keybindingLabels.ts
│ │ │ ├── keybindingParser.ts
│ │ │ ├── labels.ts
│ │ │ ├── lazy.ts
│ │ │ ├── lifecycle.ts
│ │ │ ├── linkedList.ts
│ │ │ ├── map.ts
│ │ │ ├── marked/
│ │ │ │ ├── cgmanifest.json
│ │ │ │ ├── marked.d.ts
│ │ │ │ ├── marked.js
│ │ │ │ └── marked.license.txt
│ │ │ ├── marshalling.ts
│ │ │ ├── mime.ts
│ │ │ ├── network.ts
│ │ │ ├── normalization.ts
│ │ │ ├── numbers.ts
│ │ │ ├── objects.ts
│ │ │ ├── octicon.ts
│ │ │ ├── paging.ts
│ │ │ ├── parsers.ts
│ │ │ ├── path.ts
│ │ │ ├── performance.d.ts
│ │ │ ├── performance.js
│ │ │ ├── platform.ts
│ │ │ ├── process.ts
│ │ │ ├── processes.ts
│ │ │ ├── range.ts
│ │ │ ├── resourceTree.ts
│ │ │ ├── resources.ts
│ │ │ ├── scanCode.ts
│ │ │ ├── scrollable.ts
│ │ │ ├── search.ts
│ │ │ ├── sequence.ts
│ │ │ ├── severity.ts
│ │ │ ├── stopwatch.ts
│ │ │ ├── strings.ts
│ │ │ ├── types.ts
│ │ │ ├── uint.ts
│ │ │ ├── uri.ts
│ │ │ ├── uriIpc.ts
│ │ │ ├── uuid.ts
│ │ │ └── worker/
│ │ │ └── simpleWorker.ts
│ │ ├── node/
│ │ │ ├── config.ts
│ │ │ ├── cpuUsage.sh
│ │ │ ├── crypto.ts
│ │ │ ├── decoder.ts
│ │ │ ├── encoding.ts
│ │ │ ├── extpath.ts
│ │ │ ├── id.ts
│ │ │ ├── languagePacks.d.ts
│ │ │ ├── languagePacks.js
│ │ │ ├── macAddress.ts
│ │ │ ├── paths.ts
│ │ │ ├── pfs.ts
│ │ │ ├── ports.ts
│ │ │ ├── processes.ts
│ │ │ ├── ps.sh
│ │ │ ├── ps.ts
│ │ │ ├── stream.ts
│ │ │ ├── terminateProcess.sh
│ │ │ ├── test/
│ │ │ │ └── zip.test.ts
│ │ │ ├── watcher.ts
│ │ │ └── zip.ts
│ │ ├── parts/
│ │ │ ├── contextmenu/
│ │ │ │ ├── common/
│ │ │ │ │ └── contextmenu.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── contextmenu.ts
│ │ │ │ └── electron-main/
│ │ │ │ └── contextmenu.ts
│ │ │ ├── ipc/
│ │ │ │ ├── common/
│ │ │ │ │ ├── ipc.net.ts
│ │ │ │ │ └── ipc.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── ipc.electron-browser.ts
│ │ │ │ ├── electron-main/
│ │ │ │ │ └── ipc.electron-main.ts
│ │ │ │ ├── node/
│ │ │ │ │ ├── ipc.cp.ts
│ │ │ │ │ ├── ipc.electron.ts
│ │ │ │ │ ├── ipc.net.ts
│ │ │ │ │ └── ipc.ts
│ │ │ │ └── test/
│ │ │ │ └── node/
│ │ │ │ ├── ipc.cp.test.ts
│ │ │ │ ├── ipc.net.test.ts
│ │ │ │ ├── ipc.test.ts
│ │ │ │ ├── testApp.ts
│ │ │ │ └── testService.ts
│ │ │ ├── quickopen/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── quickOpenModel.ts
│ │ │ │ │ ├── quickOpenViewer.ts
│ │ │ │ │ ├── quickOpenWidget.ts
│ │ │ │ │ └── quickopen.css
│ │ │ │ ├── common/
│ │ │ │ │ ├── quickOpen.ts
│ │ │ │ │ └── quickOpenScorer.ts
│ │ │ │ └── test/
│ │ │ │ ├── browser/
│ │ │ │ │ └── quickopen.test.ts
│ │ │ │ └── common/
│ │ │ │ └── quickOpenScorer.test.ts
│ │ │ ├── request/
│ │ │ │ ├── browser/
│ │ │ │ │ └── request.ts
│ │ │ │ └── common/
│ │ │ │ └── request.ts
│ │ │ ├── storage/
│ │ │ │ ├── common/
│ │ │ │ │ └── storage.ts
│ │ │ │ ├── node/
│ │ │ │ │ └── storage.ts
│ │ │ │ └── test/
│ │ │ │ └── node/
│ │ │ │ └── storage.test.ts
│ │ │ └── tree/
│ │ │ ├── browser/
│ │ │ │ ├── tree.css
│ │ │ │ ├── tree.ts
│ │ │ │ ├── treeDefaults.ts
│ │ │ │ ├── treeDnd.ts
│ │ │ │ ├── treeImpl.ts
│ │ │ │ ├── treeModel.ts
│ │ │ │ ├── treeUtils.ts
│ │ │ │ ├── treeView.ts
│ │ │ │ └── treeViewModel.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ ├── treeModel.test.ts
│ │ │ └── treeViewModel.test.ts
│ │ ├── test/
│ │ │ ├── browser/
│ │ │ │ ├── browser.test.ts
│ │ │ │ ├── comparers.test.ts
│ │ │ │ ├── dom.test.ts
│ │ │ │ ├── formattedTextRenderer.test.ts
│ │ │ │ ├── highlightedLabel.test.ts
│ │ │ │ ├── markdownRenderer.test.ts
│ │ │ │ ├── progressBar.test.ts
│ │ │ │ └── ui/
│ │ │ │ ├── contextview/
│ │ │ │ │ └── contextview.test.ts
│ │ │ │ ├── grid/
│ │ │ │ │ ├── grid.test.ts
│ │ │ │ │ ├── gridview.test.ts
│ │ │ │ │ └── util.ts
│ │ │ │ ├── list/
│ │ │ │ │ ├── listView.test.ts
│ │ │ │ │ └── rangeMap.test.ts
│ │ │ │ ├── menu/
│ │ │ │ │ └── menubar.test.ts
│ │ │ │ ├── scrollbar/
│ │ │ │ │ ├── scrollableElement.test.ts
│ │ │ │ │ └── scrollbarState.test.ts
│ │ │ │ ├── splitview/
│ │ │ │ │ └── splitview.test.ts
│ │ │ │ └── tree/
│ │ │ │ ├── asyncDataTree.test.ts
│ │ │ │ ├── compressedObjectTreeModel.test.ts
│ │ │ │ ├── dataTree.test.ts
│ │ │ │ ├── indexTreeModel.test.ts
│ │ │ │ ├── objectTree.test.ts
│ │ │ │ └── objectTreeModel.test.ts
│ │ │ ├── common/
│ │ │ │ ├── arrays.test.ts
│ │ │ │ ├── assert.test.ts
│ │ │ │ ├── async.test.ts
│ │ │ │ ├── cache.test.ts
│ │ │ │ ├── cancellation.test.ts
│ │ │ │ ├── charCode.test.ts
│ │ │ │ ├── collections.test.ts
│ │ │ │ ├── color.test.ts
│ │ │ │ ├── decorators.test.ts
│ │ │ │ ├── diff/
│ │ │ │ │ └── diff.test.ts
│ │ │ │ ├── errors.test.ts
│ │ │ │ ├── event.test.ts
│ │ │ │ ├── extpath.test.ts
│ │ │ │ ├── filters.perf.data.d.ts
│ │ │ │ ├── filters.perf.data.js
│ │ │ │ ├── filters.perf.test.ts
│ │ │ │ ├── filters.test.ts
│ │ │ │ ├── hash.test.ts
│ │ │ │ ├── history.test.ts
│ │ │ │ ├── iterator.test.ts
│ │ │ │ ├── json.test.ts
│ │ │ │ ├── jsonEdit.test.ts
│ │ │ │ ├── jsonFormatter.test.ts
│ │ │ │ ├── keyCodes.test.ts
│ │ │ │ ├── labels.test.ts
│ │ │ │ ├── lazy.test.ts
│ │ │ │ ├── lifecycle.test.ts
│ │ │ │ ├── linkedList.test.ts
│ │ │ │ ├── map.test.ts
│ │ │ │ ├── markdownString.test.ts
│ │ │ │ ├── marshalling.test.ts
│ │ │ │ ├── mime.test.ts
│ │ │ │ ├── objects.test.ts
│ │ │ │ ├── octicon.test.ts
│ │ │ │ ├── paging.test.ts
│ │ │ │ ├── path.test.ts
│ │ │ │ ├── processes.test.ts
│ │ │ │ ├── resourceTree.test.ts
│ │ │ │ ├── resources.test.ts
│ │ │ │ ├── scrollable.test.ts
│ │ │ │ ├── strings.test.ts
│ │ │ │ ├── types.test.ts
│ │ │ │ ├── uri.test.ts
│ │ │ │ ├── utils.ts
│ │ │ │ └── uuid.test.ts
│ │ │ └── node/
│ │ │ ├── buffer.test.ts
│ │ │ ├── config.test.ts
│ │ │ ├── console.test.ts
│ │ │ ├── decoder.test.ts
│ │ │ ├── encoding/
│ │ │ │ ├── encoding.test.ts
│ │ │ │ └── fixtures/
│ │ │ │ ├── empty.txt
│ │ │ │ ├── some.cp1252.txt
│ │ │ │ ├── some.css.qwoff
│ │ │ │ ├── some.png.txt
│ │ │ │ ├── some.qwoff.txt
│ │ │ │ ├── some.shiftjis.txt
│ │ │ │ ├── some_ansi.css
│ │ │ │ ├── some_utf16be.css
│ │ │ │ ├── some_utf16le.css
│ │ │ │ ├── some_utf8.css
│ │ │ │ ├── utf16_be_nobom.txt
│ │ │ │ └── utf16_le_nobom.txt
│ │ │ ├── extpath.test.ts
│ │ │ ├── glob.test.ts
│ │ │ ├── id.test.ts
│ │ │ ├── keytar.test.ts
│ │ │ ├── pfs/
│ │ │ │ ├── fixtures/
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── company.jxs
│ │ │ │ │ │ ├── conway.jxs
│ │ │ │ │ │ ├── employee.jxs
│ │ │ │ │ │ └── small.jxs
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── site.css
│ │ │ │ └── pfs.test.ts
│ │ │ ├── port.test.ts
│ │ │ ├── processes/
│ │ │ │ ├── fixtures/
│ │ │ │ │ ├── fork.ts
│ │ │ │ │ └── fork_large.ts
│ │ │ │ └── processes.test.ts
│ │ │ ├── testUtils.ts
│ │ │ ├── uri.test.data.txt
│ │ │ ├── uri.test.perf.ts
│ │ │ └── utils.ts
│ │ └── worker/
│ │ ├── defaultWorkerFactory.ts
│ │ └── workerMain.ts
│ ├── buildunit.json
│ ├── code/
│ │ ├── browser/
│ │ │ └── workbench/
│ │ │ ├── callback.html
│ │ │ ├── workbench-dev.html
│ │ │ ├── workbench.html
│ │ │ └── workbench.ts
│ │ ├── buildfile.js
│ │ ├── electron-browser/
│ │ │ ├── issue/
│ │ │ │ ├── issueReporter.html
│ │ │ │ ├── issueReporter.js
│ │ │ │ ├── issueReporterMain.ts
│ │ │ │ ├── issueReporterModel.ts
│ │ │ │ ├── issueReporterPage.ts
│ │ │ │ ├── issueReporterUtil.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── issueReporter.css
│ │ │ │ └── test/
│ │ │ │ └── testReporterModel.test.ts
│ │ │ ├── processExplorer/
│ │ │ │ ├── media/
│ │ │ │ │ └── processExplorer.css
│ │ │ │ ├── processExplorer.html
│ │ │ │ ├── processExplorer.js
│ │ │ │ └── processExplorerMain.ts
│ │ │ ├── proxy/
│ │ │ │ └── auth.html
│ │ │ ├── sharedProcess/
│ │ │ │ ├── contrib/
│ │ │ │ │ ├── languagePackCachedDataCleaner.ts
│ │ │ │ │ ├── logsDataCleaner.ts
│ │ │ │ │ ├── nodeCachedDataCleaner.ts
│ │ │ │ │ └── storageDataCleaner.ts
│ │ │ │ ├── sharedProcess.html
│ │ │ │ ├── sharedProcess.js
│ │ │ │ └── sharedProcessMain.ts
│ │ │ └── workbench/
│ │ │ ├── workbench.html
│ │ │ └── workbench.js
│ │ ├── electron-main/
│ │ │ ├── app.ts
│ │ │ ├── auth.ts
│ │ │ ├── main.ts
│ │ │ ├── sharedProcess.ts
│ │ │ └── window.ts
│ │ ├── node/
│ │ │ ├── activeWindowTracker.ts
│ │ │ ├── cli.ts
│ │ │ ├── cliProcessMain.ts
│ │ │ ├── paths.ts
│ │ │ └── shellEnv.ts
│ │ └── test/
│ │ ├── electron-main/
│ │ │ ├── nativeHelpers.test.ts
│ │ │ └── windowsStateStorage.test.ts
│ │ └── node/
│ │ └── argv.test.ts
│ ├── css.build.js
│ ├── css.d.ts
│ ├── css.js
│ ├── editor/
│ │ ├── browser/
│ │ │ ├── config/
│ │ │ │ ├── charWidthReader.ts
│ │ │ │ ├── configuration.ts
│ │ │ │ └── elementSizeObserver.ts
│ │ │ ├── controller/
│ │ │ │ ├── coreCommands.ts
│ │ │ │ ├── mouseHandler.ts
│ │ │ │ ├── mouseTarget.ts
│ │ │ │ ├── pointerHandler.ts
│ │ │ │ ├── textAreaHandler.css
│ │ │ │ ├── textAreaHandler.ts
│ │ │ │ ├── textAreaInput.ts
│ │ │ │ └── textAreaState.ts
│ │ │ ├── core/
│ │ │ │ ├── editorState.ts
│ │ │ │ └── keybindingCancellation.ts
│ │ │ ├── editorBrowser.ts
│ │ │ ├── editorDom.ts
│ │ │ ├── editorExtensions.ts
│ │ │ ├── services/
│ │ │ │ ├── abstractCodeEditorService.ts
│ │ │ │ ├── bulkEditService.ts
│ │ │ │ ├── codeEditorService.ts
│ │ │ │ ├── codeEditorServiceImpl.ts
│ │ │ │ └── openerService.ts
│ │ │ ├── view/
│ │ │ │ ├── dynamicViewOverlay.ts
│ │ │ │ ├── viewController.ts
│ │ │ │ ├── viewImpl.ts
│ │ │ │ ├── viewLayer.ts
│ │ │ │ ├── viewOutgoingEvents.ts
│ │ │ │ ├── viewOverlays.ts
│ │ │ │ └── viewPart.ts
│ │ │ ├── viewParts/
│ │ │ │ ├── contentWidgets/
│ │ │ │ │ └── contentWidgets.ts
│ │ │ │ ├── currentLineHighlight/
│ │ │ │ │ ├── currentLineHighlight.css
│ │ │ │ │ └── currentLineHighlight.ts
│ │ │ │ ├── currentLineMarginHighlight/
│ │ │ │ │ ├── currentLineMarginHighlight.css
│ │ │ │ │ └── currentLineMarginHighlight.ts
│ │ │ │ ├── decorations/
│ │ │ │ │ ├── decorations.css
│ │ │ │ │ └── decorations.ts
│ │ │ │ ├── editorScrollbar/
│ │ │ │ │ └── editorScrollbar.ts
│ │ │ │ ├── glyphMargin/
│ │ │ │ │ ├── glyphMargin.css
│ │ │ │ │ └── glyphMargin.ts
│ │ │ │ ├── indentGuides/
│ │ │ │ │ ├── indentGuides.css
│ │ │ │ │ └── indentGuides.ts
│ │ │ │ ├── lineNumbers/
│ │ │ │ │ ├── lineNumbers.css
│ │ │ │ │ └── lineNumbers.ts
│ │ │ │ ├── lines/
│ │ │ │ │ ├── rangeUtil.ts
│ │ │ │ │ ├── viewLine.ts
│ │ │ │ │ ├── viewLines.css
│ │ │ │ │ └── viewLines.ts
│ │ │ │ ├── linesDecorations/
│ │ │ │ │ ├── linesDecorations.css
│ │ │ │ │ └── linesDecorations.ts
│ │ │ │ ├── margin/
│ │ │ │ │ └── margin.ts
│ │ │ │ ├── marginDecorations/
│ │ │ │ │ ├── marginDecorations.css
│ │ │ │ │ └── marginDecorations.ts
│ │ │ │ ├── minimap/
│ │ │ │ │ ├── minimap.css
│ │ │ │ │ ├── minimap.ts
│ │ │ │ │ ├── minimapCharRenderer.ts
│ │ │ │ │ ├── minimapCharRendererFactory.ts
│ │ │ │ │ └── minimapCharSheet.ts
│ │ │ │ ├── overlayWidgets/
│ │ │ │ │ ├── overlayWidgets.css
│ │ │ │ │ └── overlayWidgets.ts
│ │ │ │ ├── overviewRuler/
│ │ │ │ │ ├── decorationsOverviewRuler.ts
│ │ │ │ │ └── overviewRuler.ts
│ │ │ │ ├── rulers/
│ │ │ │ │ ├── rulers.css
│ │ │ │ │ └── rulers.ts
│ │ │ │ ├── scrollDecoration/
│ │ │ │ │ ├── scrollDecoration.css
│ │ │ │ │ └── scrollDecoration.ts
│ │ │ │ ├── selections/
│ │ │ │ │ ├── selections.css
│ │ │ │ │ └── selections.ts
│ │ │ │ ├── viewCursors/
│ │ │ │ │ ├── viewCursor.ts
│ │ │ │ │ ├── viewCursors.css
│ │ │ │ │ └── viewCursors.ts
│ │ │ │ └── viewZones/
│ │ │ │ └── viewZones.ts
│ │ │ └── widget/
│ │ │ ├── codeEditorWidget.ts
│ │ │ ├── diffEditorWidget.ts
│ │ │ ├── diffNavigator.ts
│ │ │ ├── diffReview.ts
│ │ │ ├── embeddedCodeEditorWidget.ts
│ │ │ ├── inlineDiffMargin.ts
│ │ │ └── media/
│ │ │ ├── diffEditor.css
│ │ │ ├── diffReview.css
│ │ │ ├── editor.css
│ │ │ └── tokens.css
│ │ ├── common/
│ │ │ ├── commands/
│ │ │ │ ├── replaceCommand.ts
│ │ │ │ ├── shiftCommand.ts
│ │ │ │ ├── surroundSelectionCommand.ts
│ │ │ │ └── trimTrailingWhitespaceCommand.ts
│ │ │ ├── config/
│ │ │ │ ├── commonEditorConfig.ts
│ │ │ │ ├── editorOptions.ts
│ │ │ │ ├── editorZoom.ts
│ │ │ │ └── fontInfo.ts
│ │ │ ├── controller/
│ │ │ │ ├── cursor.ts
│ │ │ │ ├── cursorCollection.ts
│ │ │ │ ├── cursorColumnSelection.ts
│ │ │ │ ├── cursorCommon.ts
│ │ │ │ ├── cursorDeleteOperations.ts
│ │ │ │ ├── cursorEvents.ts
│ │ │ │ ├── cursorMoveCommands.ts
│ │ │ │ ├── cursorMoveOperations.ts
│ │ │ │ ├── cursorTypeOperations.ts
│ │ │ │ ├── cursorWordOperations.ts
│ │ │ │ ├── oneCursor.ts
│ │ │ │ └── wordCharacterClassifier.ts
│ │ │ ├── core/
│ │ │ │ ├── characterClassifier.ts
│ │ │ │ ├── editOperation.ts
│ │ │ │ ├── lineTokens.ts
│ │ │ │ ├── position.ts
│ │ │ │ ├── range.ts
│ │ │ │ ├── rgba.ts
│ │ │ │ ├── selection.ts
│ │ │ │ ├── stringBuilder.ts
│ │ │ │ └── token.ts
│ │ │ ├── diff/
│ │ │ │ └── diffComputer.ts
│ │ │ ├── editorAction.ts
│ │ │ ├── editorCommon.ts
│ │ │ ├── editorContextKeys.ts
│ │ │ ├── model/
│ │ │ │ ├── editStack.ts
│ │ │ │ ├── indentationGuesser.ts
│ │ │ │ ├── intervalTree.ts
│ │ │ │ ├── mirrorTextModel.ts
│ │ │ │ ├── pieceTreeTextBuffer/
│ │ │ │ │ ├── pieceTreeBase.ts
│ │ │ │ │ ├── pieceTreeTextBuffer.ts
│ │ │ │ │ ├── pieceTreeTextBufferBuilder.ts
│ │ │ │ │ └── rbTreeBase.ts
│ │ │ │ ├── textModel.ts
│ │ │ │ ├── textModelEvents.ts
│ │ │ │ ├── textModelSearch.ts
│ │ │ │ ├── textModelTokens.ts
│ │ │ │ ├── tokensStore.ts
│ │ │ │ └── wordHelper.ts
│ │ │ ├── model.ts
│ │ │ ├── modes/
│ │ │ │ ├── abstractMode.ts
│ │ │ │ ├── languageConfiguration.ts
│ │ │ │ ├── languageConfigurationRegistry.ts
│ │ │ │ ├── languageFeatureRegistry.ts
│ │ │ │ ├── languageSelector.ts
│ │ │ │ ├── linkComputer.ts
│ │ │ │ ├── modesRegistry.ts
│ │ │ │ ├── nullMode.ts
│ │ │ │ ├── supports/
│ │ │ │ │ ├── characterPair.ts
│ │ │ │ │ ├── electricCharacter.ts
│ │ │ │ │ ├── indentRules.ts
│ │ │ │ │ ├── inplaceReplaceSupport.ts
│ │ │ │ │ ├── onEnter.ts
│ │ │ │ │ ├── richEditBrackets.ts
│ │ │ │ │ └── tokenization.ts
│ │ │ │ ├── supports.ts
│ │ │ │ ├── textToHtmlTokenizer.ts
│ │ │ │ ├── tokenization/
│ │ │ │ │ └── typescript.ts
│ │ │ │ └── tokenizationRegistry.ts
│ │ │ ├── modes.ts
│ │ │ ├── services/
│ │ │ │ ├── editorSimpleWorker.ts
│ │ │ │ ├── editorWorkerService.ts
│ │ │ │ ├── editorWorkerServiceImpl.ts
│ │ │ │ ├── getIconClasses.ts
│ │ │ │ ├── languagesRegistry.ts
│ │ │ │ ├── markerDecorationsServiceImpl.ts
│ │ │ │ ├── markersDecorationService.ts
│ │ │ │ ├── modeService.ts
│ │ │ │ ├── modeServiceImpl.ts
│ │ │ │ ├── modelService.ts
│ │ │ │ ├── modelServiceImpl.ts
│ │ │ │ ├── resolverService.ts
│ │ │ │ ├── resourceConfiguration.ts
│ │ │ │ ├── resourceConfigurationImpl.ts
│ │ │ │ └── webWorker.ts
│ │ │ ├── standalone/
│ │ │ │ ├── promise-polyfill/
│ │ │ │ │ ├── cgmanifest.json
│ │ │ │ │ ├── polyfill.js
│ │ │ │ │ └── polyfill.license.txt
│ │ │ │ ├── standaloneBase.ts
│ │ │ │ └── standaloneEnums.ts
│ │ │ ├── standaloneStrings.ts
│ │ │ ├── view/
│ │ │ │ ├── editorColorRegistry.ts
│ │ │ │ ├── overviewZoneManager.ts
│ │ │ │ ├── renderingContext.ts
│ │ │ │ ├── viewContext.ts
│ │ │ │ ├── viewEventDispatcher.ts
│ │ │ │ └── viewEvents.ts
│ │ │ ├── viewLayout/
│ │ │ │ ├── lineDecorations.ts
│ │ │ │ ├── linesLayout.ts
│ │ │ │ ├── viewLayout.ts
│ │ │ │ ├── viewLineRenderer.ts
│ │ │ │ ├── viewLinesViewportData.ts
│ │ │ │ └── whitespaceComputer.ts
│ │ │ └── viewModel/
│ │ │ ├── characterHardWrappingLineMapper.ts
│ │ │ ├── minimapTokensColorTracker.ts
│ │ │ ├── prefixSumComputer.ts
│ │ │ ├── splitLinesCollection.ts
│ │ │ ├── viewEventHandler.ts
│ │ │ ├── viewModel.ts
│ │ │ ├── viewModelDecorations.ts
│ │ │ └── viewModelImpl.ts
│ │ ├── contrib/
│ │ │ ├── bracketMatching/
│ │ │ │ ├── bracketMatching.css
│ │ │ │ ├── bracketMatching.ts
│ │ │ │ └── test/
│ │ │ │ └── bracketMatching.test.ts
│ │ │ ├── caretOperations/
│ │ │ │ ├── caretOperations.ts
│ │ │ │ ├── moveCaretCommand.ts
│ │ │ │ ├── test/
│ │ │ │ │ └── moveCarretCommand.test.ts
│ │ │ │ └── transpose.ts
│ │ │ ├── clipboard/
│ │ │ │ ├── clipboard.css
│ │ │ │ └── clipboard.ts
│ │ │ ├── codeAction/
│ │ │ │ ├── codeAction.ts
│ │ │ │ ├── codeActionCommands.ts
│ │ │ │ ├── codeActionContributions.ts
│ │ │ │ ├── codeActionModel.ts
│ │ │ │ ├── codeActionTrigger.ts
│ │ │ │ ├── codeActionUi.ts
│ │ │ │ ├── codeActionWidget.ts
│ │ │ │ ├── lightBulbWidget.css
│ │ │ │ ├── lightBulbWidget.ts
│ │ │ │ └── test/
│ │ │ │ ├── codeAction.test.ts
│ │ │ │ └── codeActionModel.test.ts
│ │ │ ├── codelens/
│ │ │ │ ├── codeLensCache.ts
│ │ │ │ ├── codelens.ts
│ │ │ │ ├── codelensController.ts
│ │ │ │ ├── codelensWidget.css
│ │ │ │ └── codelensWidget.ts
│ │ │ ├── colorPicker/
│ │ │ │ ├── color.ts
│ │ │ │ ├── colorDetector.ts
│ │ │ │ ├── colorPicker.css
│ │ │ │ ├── colorPickerModel.ts
│ │ │ │ └── colorPickerWidget.ts
│ │ │ ├── comment/
│ │ │ │ ├── blockCommentCommand.ts
│ │ │ │ ├── comment.ts
│ │ │ │ ├── lineCommentCommand.ts
│ │ │ │ └── test/
│ │ │ │ ├── blockCommentCommand.test.ts
│ │ │ │ └── lineCommentCommand.test.ts
│ │ │ ├── contextmenu/
│ │ │ │ └── contextmenu.ts
│ │ │ ├── cursorUndo/
│ │ │ │ └── cursorUndo.ts
│ │ │ ├── dnd/
│ │ │ │ ├── dnd.css
│ │ │ │ ├── dnd.ts
│ │ │ │ └── dragAndDropCommand.ts
│ │ │ ├── documentSymbols/
│ │ │ │ ├── media/
│ │ │ │ │ ├── outlineTree.css
│ │ │ │ │ └── symbol-icons.css
│ │ │ │ ├── outline.ts
│ │ │ │ ├── outlineModel.ts
│ │ │ │ ├── outlineTree.ts
│ │ │ │ └── test/
│ │ │ │ └── outlineModel.test.ts
│ │ │ ├── find/
│ │ │ │ ├── findController.ts
│ │ │ │ ├── findDecorations.ts
│ │ │ │ ├── findModel.ts
│ │ │ │ ├── findOptionsWidget.ts
│ │ │ │ ├── findState.ts
│ │ │ │ ├── findWidget.css
│ │ │ │ ├── findWidget.ts
│ │ │ │ ├── replaceAllCommand.ts
│ │ │ │ ├── replacePattern.ts
│ │ │ │ └── test/
│ │ │ │ ├── find.test.ts
│ │ │ │ ├── findController.test.ts
│ │ │ │ ├── findModel.test.ts
│ │ │ │ └── replacePattern.test.ts
│ │ │ ├── folding/
│ │ │ │ ├── folding.css
│ │ │ │ ├── folding.ts
│ │ │ │ ├── foldingDecorations.ts
│ │ │ │ ├── foldingModel.ts
│ │ │ │ ├── foldingRanges.ts
│ │ │ │ ├── hiddenRangeModel.ts
│ │ │ │ ├── indentRangeProvider.ts
│ │ │ │ ├── intializingRangeProvider.ts
│ │ │ │ ├── syntaxRangeProvider.ts
│ │ │ │ └── test/
│ │ │ │ ├── foldingModel.test.ts
│ │ │ │ ├── foldingRanges.test.ts
│ │ │ │ ├── hiddenRangeModel.test.ts
│ │ │ │ ├── indentFold.test.ts
│ │ │ │ ├── indentRangeProvider.test.ts
│ │ │ │ └── syntaxFold.test.ts
│ │ │ ├── fontZoom/
│ │ │ │ └── fontZoom.ts
│ │ │ ├── format/
│ │ │ │ ├── format.ts
│ │ │ │ ├── formatActions.ts
│ │ │ │ └── formattingEdit.ts
│ │ │ ├── goToDefinition/
│ │ │ │ ├── clickLinkGesture.ts
│ │ │ │ ├── goToDefinition.ts
│ │ │ │ ├── goToDefinitionCommands.ts
│ │ │ │ ├── goToDefinitionMouse.css
│ │ │ │ ├── goToDefinitionMouse.ts
│ │ │ │ └── goToDefinitionResultsNavigation.ts
│ │ │ ├── gotoError/
│ │ │ │ ├── gotoError.ts
│ │ │ │ ├── gotoErrorWidget.ts
│ │ │ │ └── media/
│ │ │ │ └── gotoErrorWidget.css
│ │ │ ├── hover/
│ │ │ │ ├── getHover.ts
│ │ │ │ ├── hover.css
│ │ │ │ ├── hover.ts
│ │ │ │ ├── hoverOperation.ts
│ │ │ │ ├── hoverWidgets.ts
│ │ │ │ ├── modesContentHover.ts
│ │ │ │ └── modesGlyphHover.ts
│ │ │ ├── inPlaceReplace/
│ │ │ │ ├── inPlaceReplace.ts
│ │ │ │ └── inPlaceReplaceCommand.ts
│ │ │ ├── indentation/
│ │ │ │ ├── indentUtils.ts
│ │ │ │ ├── indentation.ts
│ │ │ │ └── test/
│ │ │ │ └── indentation.test.ts
│ │ │ ├── linesOperations/
│ │ │ │ ├── copyLinesCommand.ts
│ │ │ │ ├── linesOperations.ts
│ │ │ │ ├── moveLinesCommand.ts
│ │ │ │ ├── sortLinesCommand.ts
│ │ │ │ └── test/
│ │ │ │ ├── copyLinesCommand.test.ts
│ │ │ │ ├── linesOperations.test.ts
│ │ │ │ ├── moveLinesCommand.test.ts
│ │ │ │ └── sortLinesCommand.test.ts
│ │ │ ├── links/
│ │ │ │ ├── getLinks.ts
│ │ │ │ ├── links.css
│ │ │ │ └── links.ts
│ │ │ ├── markdown/
│ │ │ │ └── markdownRenderer.ts
│ │ │ ├── message/
│ │ │ │ ├── messageController.css
│ │ │ │ └── messageController.ts
│ │ │ ├── multicursor/
│ │ │ │ ├── multicursor.ts
│ │ │ │ └── test/
│ │ │ │ └── multicursor.test.ts
│ │ │ ├── parameterHints/
│ │ │ │ ├── parameterHints.css
│ │ │ │ ├── parameterHints.ts
│ │ │ │ ├── parameterHintsModel.ts
│ │ │ │ ├── parameterHintsWidget.ts
│ │ │ │ ├── provideSignatureHelp.ts
│ │ │ │ └── test/
│ │ │ │ └── parameterHintsModel.test.ts
│ │ │ ├── quickOpen/
│ │ │ │ └── quickOpen.ts
│ │ │ ├── referenceSearch/
│ │ │ │ ├── media/
│ │ │ │ │ ├── peekViewWidget.css
│ │ │ │ │ └── referencesWidget.css
│ │ │ │ ├── peekViewWidget.ts
│ │ │ │ ├── referenceSearch.ts
│ │ │ │ ├── referencesController.ts
│ │ │ │ ├── referencesModel.ts
│ │ │ │ ├── referencesTree.ts
│ │ │ │ ├── referencesWidget.ts
│ │ │ │ └── test/
│ │ │ │ └── referencesModel.test.ts
│ │ │ ├── rename/
│ │ │ │ ├── rename.ts
│ │ │ │ ├── renameInputField.css
│ │ │ │ └── renameInputField.ts
│ │ │ ├── smartSelect/
│ │ │ │ ├── bracketSelections.ts
│ │ │ │ ├── smartSelect.ts
│ │ │ │ ├── test/
│ │ │ │ │ └── smartSelect.test.ts
│ │ │ │ └── wordSelections.ts
│ │ │ ├── snippet/
│ │ │ │ ├── snippet.md
│ │ │ │ ├── snippetController2.ts
│ │ │ │ ├── snippetParser.ts
│ │ │ │ ├── snippetSession.css
│ │ │ │ ├── snippetSession.ts
│ │ │ │ ├── snippetVariables.ts
│ │ │ │ └── test/
│ │ │ │ ├── snippetController2.old.test.ts
│ │ │ │ ├── snippetController2.test.ts
│ │ │ │ ├── snippetParser.test.ts
│ │ │ │ ├── snippetSession.test.ts
│ │ │ │ └── snippetVariables.test.ts
│ │ │ ├── suggest/
│ │ │ │ ├── completionModel.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── suggest.css
│ │ │ │ ├── suggest.ts
│ │ │ │ ├── suggestAlternatives.ts
│ │ │ │ ├── suggestCommitCharacters.ts
│ │ │ │ ├── suggestController.ts
│ │ │ │ ├── suggestMemory.ts
│ │ │ │ ├── suggestModel.ts
│ │ │ │ ├── suggestWidget.ts
│ │ │ │ ├── test/
│ │ │ │ │ ├── completionModel.test.ts
│ │ │ │ │ ├── suggest.test.ts
│ │ │ │ │ ├── suggestMemory.test.ts
│ │ │ │ │ └── suggestModel.test.ts
│ │ │ │ ├── wordContextKey.ts
│ │ │ │ └── wordDistance.ts
│ │ │ ├── toggleTabFocusMode/
│ │ │ │ └── toggleTabFocusMode.ts
│ │ │ ├── tokenization/
│ │ │ │ └── tokenization.ts
│ │ │ ├── wordHighlighter/
│ │ │ │ └── wordHighlighter.ts
│ │ │ ├── wordOperations/
│ │ │ │ ├── test/
│ │ │ │ │ ├── wordOperations.test.ts
│ │ │ │ │ └── wordTestUtils.ts
│ │ │ │ └── wordOperations.ts
│ │ │ ├── wordPartOperations/
│ │ │ │ ├── test/
│ │ │ │ │ └── wordPartOperations.test.ts
│ │ │ │ └── wordPartOperations.ts
│ │ │ └── zoneWidget/
│ │ │ ├── zoneWidget.css
│ │ │ └── zoneWidget.ts
│ │ ├── editor.all.ts
│ │ ├── editor.api.ts
│ │ ├── editor.main.ts
│ │ ├── editor.worker.ts
│ │ ├── standalone/
│ │ │ ├── browser/
│ │ │ │ ├── accessibilityHelp/
│ │ │ │ │ ├── accessibilityHelp.css
│ │ │ │ │ └── accessibilityHelp.ts
│ │ │ │ ├── colorizer.ts
│ │ │ │ ├── iPadShowKeyboard/
│ │ │ │ │ ├── iPadShowKeyboard.css
│ │ │ │ │ └── iPadShowKeyboard.ts
│ │ │ │ ├── inspectTokens/
│ │ │ │ │ ├── inspectTokens.css
│ │ │ │ │ └── inspectTokens.ts
│ │ │ │ ├── quickOpen/
│ │ │ │ │ ├── editorQuickOpen.css
│ │ │ │ │ ├── editorQuickOpen.ts
│ │ │ │ │ ├── gotoLine.css
│ │ │ │ │ ├── gotoLine.ts
│ │ │ │ │ ├── quickCommand.ts
│ │ │ │ │ ├── quickOpenEditorWidget.ts
│ │ │ │ │ ├── quickOutline.css
│ │ │ │ │ └── quickOutline.ts
│ │ │ │ ├── referenceSearch/
│ │ │ │ │ └── standaloneReferenceSearch.ts
│ │ │ │ ├── simpleServices.ts
│ │ │ │ ├── standalone-tokens.css
│ │ │ │ ├── standaloneCodeEditor.ts
│ │ │ │ ├── standaloneCodeServiceImpl.ts
│ │ │ │ ├── standaloneEditor.ts
│ │ │ │ ├── standaloneLanguages.ts
│ │ │ │ ├── standaloneServices.ts
│ │ │ │ ├── standaloneThemeServiceImpl.ts
│ │ │ │ └── toggleHighContrast/
│ │ │ │ └── toggleHighContrast.ts
│ │ │ ├── common/
│ │ │ │ ├── monarch/
│ │ │ │ │ ├── monarchCommon.ts
│ │ │ │ │ ├── monarchCompile.ts
│ │ │ │ │ ├── monarchLexer.ts
│ │ │ │ │ └── monarchTypes.ts
│ │ │ │ ├── standaloneThemeService.ts
│ │ │ │ └── themes.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ ├── simpleServices.test.ts
│ │ │ └── standaloneLanguages.test.ts
│ │ └── test/
│ │ ├── browser/
│ │ │ ├── commands/
│ │ │ │ ├── shiftCommand.test.ts
│ │ │ │ ├── sideEditing.test.ts
│ │ │ │ └── trimTrailingWhitespaceCommand.test.ts
│ │ │ ├── controller/
│ │ │ │ ├── cursor.test.ts
│ │ │ │ ├── cursorMoveCommand.test.ts
│ │ │ │ ├── imeTester.html
│ │ │ │ ├── imeTester.ts
│ │ │ │ ├── inputRecorder.html
│ │ │ │ └── textAreaState.test.ts
│ │ │ ├── core/
│ │ │ │ └── editorState.test.ts
│ │ │ ├── editorTestServices.ts
│ │ │ ├── services/
│ │ │ │ ├── decorationRenderOptions.test.ts
│ │ │ │ └── openerService.test.ts
│ │ │ ├── testCodeEditor.ts
│ │ │ ├── testCommand.ts
│ │ │ └── view/
│ │ │ ├── minimapCharRenderer.test.ts
│ │ │ ├── minimapFontCreator.html
│ │ │ ├── minimapFontCreator.ts
│ │ │ └── viewLayer.test.ts
│ │ ├── common/
│ │ │ ├── commentMode.ts
│ │ │ ├── config/
│ │ │ │ └── commonEditorConfig.test.ts
│ │ │ ├── controller/
│ │ │ │ └── cursorMoveHelper.test.ts
│ │ │ ├── core/
│ │ │ │ ├── characterClassifier.test.ts
│ │ │ │ ├── lineTokens.test.ts
│ │ │ │ ├── range.test.ts
│ │ │ │ └── viewLineToken.ts
│ │ │ ├── diff/
│ │ │ │ └── diffComputer.test.ts
│ │ │ ├── editorTestUtils.ts
│ │ │ ├── mocks/
│ │ │ │ ├── mockMode.ts
│ │ │ │ └── testConfiguration.ts
│ │ │ ├── model/
│ │ │ │ ├── benchmark/
│ │ │ │ │ ├── benchmarkUtils.ts
│ │ │ │ │ ├── bootstrap.js
│ │ │ │ │ ├── entry.ts
│ │ │ │ │ ├── modelbuilder.benchmark.ts
│ │ │ │ │ ├── operations.benchmark.ts
│ │ │ │ │ └── searchNReplace.benchmark.ts
│ │ │ │ ├── editableTextModel.test.ts
│ │ │ │ ├── editableTextModelAuto.test.ts
│ │ │ │ ├── editableTextModelTestUtils.ts
│ │ │ │ ├── intervalTree.test.ts
│ │ │ │ ├── linesTextBuffer/
│ │ │ │ │ ├── linesTextBuffer.test.ts
│ │ │ │ │ ├── linesTextBufferBuilder.test.ts
│ │ │ │ │ └── textBufferAutoTestUtils.ts
│ │ │ │ ├── model.line.test.ts
│ │ │ │ ├── model.modes.test.ts
│ │ │ │ ├── model.test.ts
│ │ │ │ ├── modelDecorations.test.ts
│ │ │ │ ├── modelEditOperation.test.ts
│ │ │ │ ├── pieceTreeTextBuffer/
│ │ │ │ │ └── pieceTreeTextBuffer.test.ts
│ │ │ │ ├── textModel.test.ts
│ │ │ │ ├── textModelSearch.test.ts
│ │ │ │ └── textModelWithTokens.test.ts
│ │ │ ├── modes/
│ │ │ │ ├── languageConfiguration.test.ts
│ │ │ │ ├── languageSelector.test.ts
│ │ │ │ ├── linkComputer.test.ts
│ │ │ │ ├── supports/
│ │ │ │ │ ├── characterPair.test.ts
│ │ │ │ │ ├── electricCharacter.test.ts
│ │ │ │ │ ├── javascriptOnEnterRules.ts
│ │ │ │ │ ├── onEnter.test.ts
│ │ │ │ │ ├── richEditBrackets.test.ts
│ │ │ │ │ └── tokenization.test.ts
│ │ │ │ └── textToHtmlTokenizer.test.ts
│ │ │ ├── modesTestUtils.ts
│ │ │ ├── services/
│ │ │ │ ├── editorSimpleWorker.test.ts
│ │ │ │ ├── languagesRegistry.test.ts
│ │ │ │ └── modelService.test.ts
│ │ │ ├── view/
│ │ │ │ └── overviewZoneManager.test.ts
│ │ │ ├── viewLayout/
│ │ │ │ ├── editorLayoutProvider.test.ts
│ │ │ │ ├── lineDecorations.test.ts
│ │ │ │ ├── linesLayout.test.ts
│ │ │ │ ├── viewLineRenderer.test.ts
│ │ │ │ └── whitespaceComputer.test.ts
│ │ │ └── viewModel/
│ │ │ ├── characterHardWrappingLineMapper.test.ts
│ │ │ ├── prefixSumComputer.test.ts
│ │ │ ├── splitLinesCollection.test.ts
│ │ │ ├── testViewModel.ts
│ │ │ ├── viewModelDecorations.test.ts
│ │ │ └── viewModelImpl.test.ts
│ │ └── node/
│ │ └── classification/
│ │ ├── typescript-test.ts
│ │ └── typescript.test.ts
│ ├── kendryte/
│ │ ├── main.main.ts
│ │ ├── vs/
│ │ │ ├── base/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── dom.ts
│ │ │ │ │ └── ui/
│ │ │ │ │ ├── editableSelect.css
│ │ │ │ │ ├── editableSelect.scss
│ │ │ │ │ ├── editableSelect.ts
│ │ │ │ │ ├── lazyInputBox.ts
│ │ │ │ │ ├── myCheckBox.css
│ │ │ │ │ ├── myCheckBox.scss
│ │ │ │ │ ├── myCheckBox.ts
│ │ │ │ │ └── selectBox.ts
│ │ │ │ ├── common/
│ │ │ │ │ ├── arrayUnique.ts
│ │ │ │ │ ├── assertNotNull.ts
│ │ │ │ │ ├── cmakeTypeHelper.ts
│ │ │ │ │ ├── configKeys.ts
│ │ │ │ │ ├── constants/
│ │ │ │ │ │ ├── remoteRegistry.ts
│ │ │ │ │ │ └── wellknownFiles.ts
│ │ │ │ │ ├── cpp/
│ │ │ │ │ │ └── wrapHeaderFile.ts
│ │ │ │ │ ├── deferredPromise.ts
│ │ │ │ │ ├── doubleExtname.ts
│ │ │ │ │ ├── drainStream.ts
│ │ │ │ │ ├── dumpDate.ts
│ │ │ │ │ ├── dumpEventEmitter.ts
│ │ │ │ │ ├── extendMap.ts
│ │ │ │ │ ├── filterProjectName.ts
│ │ │ │ │ ├── finishAllPromise.ts
│ │ │ │ │ ├── fs/
│ │ │ │ │ │ └── isSameDrive.ts
│ │ │ │ │ ├── guaranteeDebounce.ts
│ │ │ │ │ ├── ipcIds.ts
│ │ │ │ │ ├── jsonComments.ts
│ │ │ │ │ ├── jsonSchemaHelper/
│ │ │ │ │ │ ├── commonTypes.ts
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ ├── jsonSchemas/
│ │ │ │ │ │ ├── cmakeConfigSchema.ts
│ │ │ │ │ │ ├── deviceManagerSchema.ts
│ │ │ │ │ │ └── flashSectionsSchema.ts
│ │ │ │ │ ├── lifecycle/
│ │ │ │ │ │ ├── disposableSet.ts
│ │ │ │ │ │ ├── publicDisposable.ts
│ │ │ │ │ │ ├── stackArray.ts
│ │ │ │ │ │ └── statefulDisposable.ts
│ │ │ │ │ ├── log.ts
│ │ │ │ │ ├── menu/
│ │ │ │ │ │ ├── cmake.ts
│ │ │ │ │ │ ├── kendryteMenuDefine.ts
│ │ │ │ │ │ ├── openocd.ts
│ │ │ │ │ │ ├── packageManager.ts
│ │ │ │ │ │ ├── processTool.ts
│ │ │ │ │ │ ├── serialPort.ts
│ │ │ │ │ │ ├── tools.ts
│ │ │ │ │ │ └── webLink.ts
│ │ │ │ │ ├── messages.ts
│ │ │ │ │ ├── normalizeArray.ts
│ │ │ │ │ ├── objectPath.ts
│ │ │ │ │ ├── platform.ts
│ │ │ │ │ ├── platformEnv.ts
│ │ │ │ │ ├── resolvePath.ts
│ │ │ │ │ ├── simpleIdProvider.ts
│ │ │ │ │ ├── speedShow.ts
│ │ │ │ │ ├── textProgressBar.ts
│ │ │ │ │ ├── timeout.ts
│ │ │ │ │ ├── type/
│ │ │ │ │ │ ├── deepReadonly.ts
│ │ │ │ │ │ └── objectKeys.ts
│ │ │ │ │ ├── urlList.ts
│ │ │ │ │ ├── utils.ts
│ │ │ │ │ └── workerPool.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── rawClipboardAction.ts
│ │ │ │ ├── electron-main/
│ │ │ │ │ ├── errorStack.ts
│ │ │ │ │ └── injection/
│ │ │ │ │ └── registry.ts
│ │ │ │ └── node/
│ │ │ │ ├── blackHoleStream.ts
│ │ │ │ ├── chunkBuffer.ts
│ │ │ │ ├── collectingStream.ts
│ │ │ │ ├── copyPreserve.ts
│ │ │ │ ├── disposableEvents.ts
│ │ │ │ ├── disposableStream.ts
│ │ │ │ ├── extrafs.ts
│ │ │ │ ├── fileLock.ts
│ │ │ │ ├── hash.ts
│ │ │ │ ├── loggerStream.ts
│ │ │ │ ├── processPromise.ts
│ │ │ │ ├── replaceBuffer.ts
│ │ │ │ ├── splitBuffer.ts
│ │ │ │ ├── streamPromise.ts
│ │ │ │ └── terminalConst.ts
│ │ │ ├── code/
│ │ │ │ ├── code.main.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── updater/
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── createReportAction.ts
│ │ │ │ │ │ ├── quitUpdateAction.ts
│ │ │ │ │ │ └── rebootAction.ts
│ │ │ │ │ └── register.ts
│ │ │ │ └── electron-main/
│ │ │ │ ├── checkHealth.ts
│ │ │ │ └── createServices.injection.ts
│ │ │ ├── platform/
│ │ │ │ ├── config/
│ │ │ │ │ └── common/
│ │ │ │ │ ├── category.ts
│ │ │ │ │ ├── dynamicEnum.ts
│ │ │ │ │ ├── progress.ts
│ │ │ │ │ └── registry.ts
│ │ │ │ ├── createShortcut/
│ │ │ │ │ └── node/
│ │ │ │ │ └── shortcuts.ts
│ │ │ │ ├── fileDialog/
│ │ │ │ │ └── common/
│ │ │ │ │ ├── configContribution.ts
│ │ │ │ │ ├── configKeys.ts
│ │ │ │ │ ├── globalIgnore.ts
│ │ │ │ │ └── sourceFile.ts
│ │ │ │ ├── instantiation/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── ipcExtensions.ts
│ │ │ │ │ │ └── mainExtensions.ts
│ │ │ │ │ └── electron-main/
│ │ │ │ │ └── mainIpcExtensions.ts
│ │ │ │ ├── log/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ └── valueNotify.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── consoleLogger.ts
│ │ │ │ ├── marker/
│ │ │ │ │ └── common/
│ │ │ │ │ ├── errorWithPath.ts
│ │ │ │ │ └── simple.ts
│ │ │ │ ├── notify/
│ │ │ │ │ └── common/
│ │ │ │ │ └── promiseNotification.ts
│ │ │ │ ├── open/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── actionIds.ts
│ │ │ │ │ │ ├── chipConst.ts
│ │ │ │ │ │ ├── openDocumentInBrowser.ts
│ │ │ │ │ │ ├── openForumInBrowser.ts
│ │ │ │ │ │ └── openUrlAction.ts
│ │ │ │ │ └── electron-browser/
│ │ │ │ │ └── register.ts
│ │ │ │ ├── openocd/
│ │ │ │ │ └── common/
│ │ │ │ │ ├── custom.ts
│ │ │ │ │ ├── ftdi.ts
│ │ │ │ │ ├── jtag.ts
│ │ │ │ │ └── openocd.ts
│ │ │ │ ├── serialPort/
│ │ │ │ │ ├── fastFlasher/
│ │ │ │ │ │ └── node/
│ │ │ │ │ │ ├── fastLoader.ts
│ │ │ │ │ │ ├── response.ts
│ │ │ │ │ │ └── serialReduceStream.ts
│ │ │ │ │ ├── flashCommon/
│ │ │ │ │ │ └── node/
│ │ │ │ │ │ ├── dataBufferPack.ts
│ │ │ │ │ │ ├── programBufferPack.ts
│ │ │ │ │ │ └── tryReboot.ts
│ │ │ │ │ └── flasher/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── chipDefine.ts
│ │ │ │ │ │ ├── memoryAllocationCalculator.ts
│ │ │ │ │ │ └── sections.ts
│ │ │ │ │ └── node/
│ │ │ │ │ ├── baseTransform.ts
│ │ │ │ │ ├── bufferConsts.ts
│ │ │ │ │ ├── chunkBuffer.ts
│ │ │ │ │ ├── escapeBuffer.ts
│ │ │ │ │ ├── flasher.ts
│ │ │ │ │ ├── fourBytesReverser.ts
│ │ │ │ │ ├── ispBuffer.ts
│ │ │ │ │ ├── ispFlashPackage.ts
│ │ │ │ │ ├── quotedBuffer.ts
│ │ │ │ │ ├── streamChain.ts
│ │ │ │ │ └── timoutBuffer.ts
│ │ │ │ ├── sudo/
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ └── register.ts
│ │ │ │ │ ├── electron-main/
│ │ │ │ │ │ └── register.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── sudoService.ts
│ │ │ │ ├── vscode/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── relaunchService.ts
│ │ │ │ │ │ └── socket.ts
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ └── relaunchRenderService.ts
│ │ │ │ │ ├── electron-main/
│ │ │ │ │ │ └── relaunchMainService.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── myVersion.ts
│ │ │ │ └── vsicons/
│ │ │ │ ├── README.md
│ │ │ │ └── browser/
│ │ │ │ ├── icons/
│ │ │ │ │ ├── style.css
│ │ │ │ │ └── style.scss
│ │ │ │ └── vsIconRender.ts
│ │ │ ├── services/
│ │ │ │ ├── channelLogger/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── logger.ts
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ └── service.ts
│ │ │ │ │ └── electron-main/
│ │ │ │ │ ├── remoteLogger.ts
│ │ │ │ │ └── service.ts
│ │ │ │ ├── download/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ └── download.ts
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ ├── downloadWithProgressService.ts
│ │ │ │ │ │ └── nodeDownloadService.ts
│ │ │ │ │ ├── electron-main/
│ │ │ │ │ │ ├── downloadTask.ts
│ │ │ │ │ │ └── nodeDownloadService.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── nodeRequestService.ts
│ │ │ │ ├── fileCompress/
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ └── contribution.ts
│ │ │ │ │ ├── electron-main/
│ │ │ │ │ │ └── contribution.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── fileCompressService.ts
│ │ │ │ ├── fileSystem/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── nodeFileSystemService.ts
│ │ │ │ ├── github/
│ │ │ │ │ └── node/
│ │ │ │ │ └── githubServiceContribution.ts
│ │ │ │ ├── ipc/
│ │ │ │ │ ├── browser/
│ │ │ │ │ │ ├── ipc.ts
│ │ │ │ │ │ └── ipcChannelWorkbench.ts
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── ipcType.ts
│ │ │ │ │ │ ├── reflect.ts
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ └── electron-main/
│ │ │ │ │ ├── ipc.ts
│ │ │ │ │ ├── ipcChannelMain.ts
│ │ │ │ │ └── ipcType.ts
│ │ │ │ ├── makefileService/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── createCMakeListsAction.ts
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ ├── node/
│ │ │ │ │ │ ├── contribution.ts
│ │ │ │ │ │ ├── extensionHandler.ts
│ │ │ │ │ │ ├── makefileService.ts
│ │ │ │ │ │ ├── resolve.ts
│ │ │ │ │ │ └── write.ts
│ │ │ │ │ └── superFlash/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ └── node/
│ │ │ │ │ ├── configContribution.ts
│ │ │ │ │ ├── superFlashHookContribution.ts
│ │ │ │ │ └── superFlashService.ts
│ │ │ │ ├── openocd/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── channel.ts
│ │ │ │ │ │ └── openOCDService.ts
│ │ │ │ │ └── electron-browser/
│ │ │ │ │ ├── actionConfigContribution.ts
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── jtagBase.ts
│ │ │ │ │ │ ├── jtagFindId.ts
│ │ │ │ │ │ └── openocdStartStopAction.ts
│ │ │ │ │ └── openOCDService.ts
│ │ │ │ ├── path/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ ├── electron-browser/
│ │ │ │ │ │ └── contribution.ts
│ │ │ │ │ ├── electron-main/
│ │ │ │ │ │ └── contribution.ts
│ │ │ │ │ └── node/
│ │ │ │ │ └── nodePathService.ts
│ │ │ │ ├── serialPort/
│ │ │ │ │ ├── common/
│ │ │ │ │ │ ├── actionId.ts
│ │ │ │ │ │ ├── configContribution.ts
│ │ │ │ │ │ ├── libraryType.ts
│ │ │ │ │ │ ├── rebootSequence.ts
│ │ │ │ │ │ ├── reloadAction.ts
│ │ │ │ │ │ ├── standard.ts
│ │ │ │ │ │ └── type.ts
│ │ │ │ │ └── node/
│ │ │ │ │ ├── serialPortInstance.ts
│ │ │ │ │ ├── serialPortManager.ts
│ │ │ │ │ └── serialPortService.ts
│ │ │ │ ├── storage/
│ │ │ │ │ └── electron-main/
│ │ │ │ │ └── contribution.ts
│ │ │ │ └── workspace/
│ │ │ │ ├── common/
│ │ │ │ │ ├── actionId.ts
│ │ │ │ │ ├── contextKey.ts
│ │ │ │ │ └── type.ts
│ │ │ │ └── electron-browser/
│ │ │ │ ├── contribution.ts
│ │ │ │ ├── kendryteWorkspaceService.ts
│ │ │ │ └── selectProjectAction.ts
│ │ │ └── workbench/
│ │ │ ├── actionRegistry/
│ │ │ │ └── common/
│ │ │ │ ├── openDevToolsAction.ts
│ │ │ │ └── registerAction.ts
│ │ │ ├── bootstrap/
│ │ │ │ └── electron-browser/
│ │ │ │ └── kendryteBootstrap.ts
│ │ │ ├── bottomBar/
│ │ │ │ ├── common/
│ │ │ │ │ ├── buttonSize.css
│ │ │ │ │ ├── buttonSize.scss
│ │ │ │ │ ├── kendryteButtonContribution.ts
│ │ │ │ │ ├── kendryteStatusControllerService.ts
│ │ │ │ │ ├── myStatusBarItem.ts
│ │ │ │ │ ├── myStatusBarItemId.ts
│ │ │ │ │ └── type.ts
│ │ │ │ └── electron-browser/
│ │ │ │ └── statusBarContribution.ts
│ │ │ ├── cmake/
│ │ │ │ ├── common/
│ │ │ │ │ ├── actionIds.ts
│ │ │ │ │ ├── cmakeProtocol/
│ │ │ │ │ │ ├── cmakeProtocol.ts
│ │ │ │ │ │ ├── config.ts
│ │ │ │ │ │ ├── ctest.ts
│ │ │ │ │ │ ├── error.ts
│ │ │ │ │ │ ├── event.ts
│ │ │ │ │ │ ├── message.ts
│ │ │ │ │ │ ├── settings.ts
│ │ │ │ │ │ └── singal.ts
│ │ │ │ │ ├── configFile.ts
│ │ │ │ │ ├── errors.ts
│ │ │ │ │ ├── launchConfig.ts
│ │ │ │ │ └── type.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── buildAction.ts
│ │ │ │ │ │ ├── cleanupAction.ts
│ │ │ │ │ │ ├── configureAction.ts
│ │ │ │ │ │ ├── debugAction.ts
│ │ │ │ │ │ ├── helloWorldAction.ts
│ │ │ │ │ │ ├── openLocalCMakeList.ts
│ │ │ │ │ │ ├── openLogAction.ts
│ │ │ │ │ │ ├── runAction.ts
│ │ │ │ │ │ ├── selectTargetAction.ts
│ │ │ │ │ │ └── selectVariantAction.ts
│ │ │ │ │ ├── cmakeContribution.ts
│ │ │ │ │ ├── cmakeService.ts
│ │ │ │ │ └── maixBuildSystemService.ts
│ │ │ │ └── node/
│ │ │ │ ├── cmakeCache.ts
│ │ │ │ ├── commandExists.ts
│ │ │ │ ├── environmentVars.ts
│ │ │ │ ├── outputProcessor.ts
│ │ │ │ └── rimraf.ts
│ │ │ ├── commonDomBlocks/
│ │ │ │ └── browser/
│ │ │ │ ├── simpleNavBar.css
│ │ │ │ ├── simpleNavBar.ts
│ │ │ │ ├── simpleTabControl.ts
│ │ │ │ ├── splitRender.ts
│ │ │ │ └── tabControl.css
│ │ │ ├── config/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── categoryContribution.ts
│ │ │ │ │ └── internalSettingsCategoryContribution.ts
│ │ │ │ ├── common/
│ │ │ │ │ ├── flashSettingsContribution.ts
│ │ │ │ │ └── type.ts
│ │ │ │ └── electron-browser/
│ │ │ │ └── pathSettingsContribution.ts
│ │ │ ├── flashManager/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── flashManagerEditor.ts
│ │ │ │ │ ├── list.ts
│ │ │ │ │ ├── style.css
│ │ │ │ │ └── style.scss
│ │ │ │ ├── common/
│ │ │ │ │ ├── editorInput.ts
│ │ │ │ │ ├── editorModel.ts
│ │ │ │ │ ├── flashManagerService.ts
│ │ │ │ │ ├── openFlashManagerAction.ts
│ │ │ │ │ └── type.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── flashManagerContribution.ts
│ │ │ │ └── node/
│ │ │ │ ├── createZipAction.ts
│ │ │ │ ├── flashAllAction.ts
│ │ │ │ ├── flashHookContribution.ts
│ │ │ │ └── flashManagerService.ts
│ │ │ ├── fpioaConfig/
│ │ │ │ ├── common/
│ │ │ │ │ ├── baseAny.ts
│ │ │ │ │ ├── bga.ts
│ │ │ │ │ ├── builder.ts
│ │ │ │ │ ├── fpioaModel.ts
│ │ │ │ │ ├── ids.ts
│ │ │ │ │ ├── packagingRegistry.ts
│ │ │ │ │ ├── packagingTypes.ts
│ │ │ │ │ ├── packagings/
│ │ │ │ │ │ ├── includeAllContribution.ts
│ │ │ │ │ │ ├── maix1.functions.ts
│ │ │ │ │ │ └── maix1.ts
│ │ │ │ │ ├── packagingsContribution.ts
│ │ │ │ │ └── types.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ ├── editor/
│ │ │ │ │ │ ├── fpioaEditor.css
│ │ │ │ │ │ ├── fpioaEditor.ts
│ │ │ │ │ │ ├── left/
│ │ │ │ │ │ │ ├── chipSelectView.ts
│ │ │ │ │ │ │ ├── funcMapListItemView.ts
│ │ │ │ │ │ │ ├── groupTitleView.ts
│ │ │ │ │ │ │ ├── ids.ts
│ │ │ │ │ │ │ └── splitView.ts
│ │ │ │ │ │ ├── leftPanel.ts
│ │ │ │ │ │ ├── right/
│ │ │ │ │ │ │ ├── abstract.ts
│ │ │ │ │ │ │ ├── bgaTable.ts
│ │ │ │ │ │ │ ├── cell.ts
│ │ │ │ │ │ │ └── factory.ts
│ │ │ │ │ │ └── rightPanel.ts
│ │ │ │ │ ├── fpioaActions.ts
│ │ │ │ │ ├── fpioaContribution.ts
│ │ │ │ │ └── fpioaEditorInput.ts
│ │ │ │ └── node/
│ │ │ │ └── fpioaService.ts
│ │ │ ├── jsonGUIEditor/
│ │ │ │ ├── common/
│ │ │ │ │ ├── contribution.ts
│ │ │ │ │ ├── register.ts
│ │ │ │ │ └── type.ts
│ │ │ │ ├── editor/
│ │ │ │ │ ├── browser/
│ │ │ │ │ │ ├── abstractJsonEditor.ts
│ │ │ │ │ │ ├── abstractJsonEditorInput.ts
│ │ │ │ │ │ ├── editorDescriptor.ts
│ │ │ │ │ │ ├── style.css
│ │ │ │ │ │ └── style.scss
│ │ │ │ │ └── common/
│ │ │ │ │ ├── actionId.ts
│ │ │ │ │ ├── context.ts
│ │ │ │ │ ├── inputFactory.ts
│ │ │ │ │ ├── replaceEditor.ts
│ │ │ │ │ ├── switchEditorAction.ts
│ │ │ │ │ └── type.ts
│ │ │ │ └── service/
│ │ │ │ ├── common/
│ │ │ │ │ └── type.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ └── contribution.ts
│ │ │ │ └── node/
│ │ │ │ ├── customJsonEditorService.ts
│ │ │ │ └── simpleJsonEditorModel.ts
│ │ │ ├── kendrytePackageJsonEditor/
│ │ │ │ ├── browser/
│ │ │ │ │ └── media/
│ │ │ │ │ ├── kendrytePackageJsonEditor.css
│ │ │ │ │ └── kendrytePackageJsonEditor.scss
│ │ │ │ ├── common/
│ │ │ │ │ ├── ids.ts
│ │ │ │ │ └── type.ts
│ │ │ │ ├── electron-browser/
│ │ │ │ │ ├── fields/
│ │ │ │ │ │ ├── base.ts
│ │ │ │ │ │ ├── dependency.ts
│ │ │ │ │ │ ├── folderList.ts
│ │ │ │ │ │ ├── singleFile.ts
│ │ │ │ │ │ ├── singleFolder.ts
│ │ │ │ │ │ └── sourceFileList.ts
│ │ │ │ │ ├── kendryteJsonContribution.ts
│ │ │ │ │ ├── kendrytePackageJsonEditor.ts
│ │ │ │ │ ├── kendrytePackageJsonEditorInput.ts
│ │ │ │ │ ├── openPackageJsonEditorAction.ts
│ │ │ │ │ └── sectionFactory.ts
│ │ │ │ └── node/
│ │ │ │ ├── validators.class.ts
│ │ │ │ └── validators.ts
│ │ │ ├── packageManager/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── actions/
│ │ │ │ │ │ ├── deleteDependencyAction.ts
│ │ │ │ │ │ ├── displayPackageDetailAction.ts
│ │ │ │ │ │ ├── installDependencyAction.ts
│ │ │ │ │ │ └── openPackagesMarketPlaceAction.ts
│ │ │ │ │ ├── actionsContribution.ts
│ │ │ │ │ ├── assertValidWorkspace.ts
│ │ │ │ │ ├── editors/
│ │ │ │ │ │ ├── detailPage.css
│ │ │ │ │ │ ├── markdown.css
│ │ │ │ │ │ ├── packageBrowser.ts
│ │ │ │ │ │ ├── packageDetail.ts
│ │ │ │ │ │ └── remotePackagesListView.ts
│ │ │ │ │ ├── media/
│ │ │ │ │ │ └── package-manager.css
│ │ │ │ │ ├── packageManagerViewlet.ts
│ │ │ │ │ └── viewletPanels/
│ │ │ │ │ ├── localPackagesListView.ts
│ │ │ │ │ ├── packageConfigView.ts
│ │ │ │ │ ├── register.ts
│ │ │ │ │ └── side-bar.css
│ │ │ │ ├── common/
│ │ │ │ │ ├── distribute.ts
│ │ │ │ │ ├── editors/
│ │ │ │ │ │ ├── packageBrowserInput.ts
│ │ │ │ │ │ └── packageDetailInput.ts
│ │ │ │ │ └── type.ts
│ │ │ │ └── electron-browser/
│ │ │ │ ├── mainPanelContribution.ts
│ │ │ │ └── packageRegistryService.ts
│ │ │ ├── popupViewer/
│ │ │ │ └── browser/
│ │ │ │ ├── frame.css
│ │ │ │ ├── frame.html
│ │ │ │ └── fullScreenViewer.ts
│ │ │ ├── progress/
│ │ │ │ └── common/
│ │ │ │ └── unClosableNotify.ts
│ │ │ ├── serialMonitor/
│ │ │ │ ├── browser/
│ │ │ │ │ ├── SerialMonitorUIConfig.ts
│ │ │ │ │ ├── fields/
│ │ │ │ │ │ ├── base.ts
│ │ │ │ │ │ ├── select.ts
│ │ │ │ │ │ └── text.ts
│ │ │ │ │ ├── media/
│ │ │ │ │ │ ├── panel.css
│ │ │ │ │ │ └── panel.scss
│ │ │ │ │ └── serialMonitorSettings.ts
│ │ │ │ ├── common/
│ │ │ │ │ ├── actionId.ts
│ │ │ │ │ ├── configContribution.ts
│ │ │ │ │ ├── localSettings.ts
│ │ │ │ │ ├── schema.ts
│ │ │ │ │ ├── serialMonitorData.ts
│ │ │ │ │ └── toggleSerialMonitorAction.ts
│ │ │ │ └── electron-browser/
│ │ │ │ ├── actions/
│ │ │ │ │ ├── acceptSerialInput.ts
│ │ │ │ │ ├── clear.ts
│ │ │ │ │ ├── copyPaste.ts
│ │ │ │ │ ├── find.ts
│ │ │ │ │ └── register.ts
│ │ │ │ ├── fakeTerminalProcessManager.ts
│ │ │ │ ├── iobuffers/
│ │ │ │ │ ├── input.ts
│ │ │ │ │ ├── output.ts
│ │ │ │ │ └── streamEncoder.ts
│ │ │ │ ├── outputWindow.ts
│ │ │ │ ├── outputWindowControlService.ts
│ │ │ │ ├── outputWindowFind.ts
│ │ │ │ ├── serialDeviceList.ts
│ │ │ │ ├── serialMonitorPanel.ts
│ │ │ │ ├── serialPrivateReplService.ts
│ │ │ │ ├── serialReplHistory.ts
│ │ │ │ ├── serialReplInput.ts
│ │ │ │ └── serialScope.ts
│ │ │ ├── serialUpload/
│ │ │ │ ├── common/
│ │ │ │ │ └── configContribution.ts
│ │ │ │ └── node/
│ │ │ │ ├── rebootAction.ts
│ │ │ │ ├── selectDefaultAction.ts
│ │ │ │ ├── uploadAction.ts
│ │ │ │ └── uploadContribution.ts
│ │ │ └── topMenu/
│ │ │ ├── common/
│ │ │ │ └── title.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── kendryteMenuContribution.ts
│ │ │ └── node/
│ │ │ ├── darwin.ts
│ │ │ ├── linux.ts
│ │ │ ├── shortcutsContribution.ts
│ │ │ └── windows.ts
│ │ └── workbench.main.ts
│ ├── loader.js
│ ├── monaco.d.ts
│ ├── nls.build.js
│ ├── nls.d.ts
│ ├── nls.js
│ ├── nls.mock.ts
│ ├── platform/
│ │ ├── accessibility/
│ │ │ └── common/
│ │ │ ├── abstractAccessibilityService.ts
│ │ │ ├── accessibility.ts
│ │ │ └── accessibilityService.ts
│ │ ├── actions/
│ │ │ ├── browser/
│ │ │ │ └── menuEntryActionViewItem.ts
│ │ │ ├── common/
│ │ │ │ ├── actions.ts
│ │ │ │ └── menuService.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── menuService.test.ts
│ │ ├── auth/
│ │ │ └── common/
│ │ │ ├── auth.ts
│ │ │ ├── authTokenIpc.ts
│ │ │ └── authTokenService.ts
│ │ ├── backup/
│ │ │ ├── electron-main/
│ │ │ │ ├── backup.ts
│ │ │ │ └── backupMainService.ts
│ │ │ ├── node/
│ │ │ │ └── backup.ts
│ │ │ └── test/
│ │ │ └── electron-main/
│ │ │ └── backupMainService.test.ts
│ │ ├── browser/
│ │ │ └── contextScopedHistoryWidget.ts
│ │ ├── clipboard/
│ │ │ └── common/
│ │ │ └── clipboardService.ts
│ │ ├── commands/
│ │ │ ├── common/
│ │ │ │ └── commands.ts
│ │ │ └── test/
│ │ │ └── commands.test.ts
│ │ ├── configuration/
│ │ │ ├── common/
│ │ │ │ ├── configuration.ts
│ │ │ │ ├── configurationModels.ts
│ │ │ │ └── configurationRegistry.ts
│ │ │ ├── node/
│ │ │ │ └── configurationService.ts
│ │ │ └── test/
│ │ │ ├── common/
│ │ │ │ ├── configuration.test.ts
│ │ │ │ ├── configurationModels.test.ts
│ │ │ │ └── testConfigurationService.ts
│ │ │ └── node/
│ │ │ └── configurationService.test.ts
│ │ ├── contextkey/
│ │ │ ├── browser/
│ │ │ │ └── contextKeyService.ts
│ │ │ ├── common/
│ │ │ │ ├── contextkey.ts
│ │ │ │ └── contextkeys.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── contextkey.test.ts
│ │ ├── contextview/
│ │ │ └── browser/
│ │ │ ├── contextMenuHandler.css
│ │ │ ├── contextMenuHandler.ts
│ │ │ ├── contextMenuService.ts
│ │ │ ├── contextView.ts
│ │ │ └── contextViewService.ts
│ │ ├── credentials/
│ │ │ ├── common/
│ │ │ │ └── credentials.ts
│ │ │ └── node/
│ │ │ └── credentialsService.ts
│ │ ├── debug/
│ │ │ └── common/
│ │ │ ├── extensionHostDebug.ts
│ │ │ └── extensionHostDebugIpc.ts
│ │ ├── diagnostics/
│ │ │ ├── common/
│ │ │ │ └── diagnostics.ts
│ │ │ └── node/
│ │ │ ├── diagnosticsIpc.ts
│ │ │ └── diagnosticsService.ts
│ │ ├── dialogs/
│ │ │ ├── common/
│ │ │ │ └── dialogs.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── dialogIpc.ts
│ │ │ ├── electron-main/
│ │ │ │ └── dialogs.ts
│ │ │ └── node/
│ │ │ └── dialogs.ts
│ │ ├── download/
│ │ │ └── common/
│ │ │ ├── download.ts
│ │ │ ├── downloadIpc.ts
│ │ │ └── downloadService.ts
│ │ ├── driver/
│ │ │ ├── browser/
│ │ │ │ ├── baseDriver.ts
│ │ │ │ └── driver.ts
│ │ │ ├── common/
│ │ │ │ └── driver.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── driver.ts
│ │ │ ├── electron-main/
│ │ │ │ └── driver.ts
│ │ │ └── node/
│ │ │ └── driver.ts
│ │ ├── editor/
│ │ │ └── common/
│ │ │ └── editor.ts
│ │ ├── electron/
│ │ │ ├── electron-main/
│ │ │ │ └── electronMainService.ts
│ │ │ └── node/
│ │ │ └── electron.ts
│ │ ├── environment/
│ │ │ ├── common/
│ │ │ │ └── environment.ts
│ │ │ ├── node/
│ │ │ │ ├── argv.ts
│ │ │ │ ├── argvHelper.ts
│ │ │ │ └── environmentService.ts
│ │ │ └── test/
│ │ │ └── node/
│ │ │ └── environmentService.test.ts
│ │ ├── extensionManagement/
│ │ │ ├── common/
│ │ │ │ ├── extensionGalleryService.ts
│ │ │ │ ├── extensionManagement.ts
│ │ │ │ ├── extensionManagementIpc.ts
│ │ │ │ ├── extensionManagementUtil.ts
│ │ │ │ └── extensionNls.ts
│ │ │ ├── node/
│ │ │ │ ├── extensionLifecycle.ts
│ │ │ │ ├── extensionManagementService.ts
│ │ │ │ ├── extensionManagementUtil.ts
│ │ │ │ └── extensionsManifestCache.ts
│ │ │ └── test/
│ │ │ ├── electron-browser/
│ │ │ │ └── extensionManagement.test.ts
│ │ │ └── node/
│ │ │ └── extensionGalleryService.test.ts
│ │ ├── extensions/
│ │ │ ├── common/
│ │ │ │ ├── extensionValidator.ts
│ │ │ │ └── extensions.ts
│ │ │ └── test/
│ │ │ └── node/
│ │ │ └── extensionValidator.test.ts
│ │ ├── files/
│ │ │ ├── common/
│ │ │ │ ├── fileService.ts
│ │ │ │ └── files.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── diskFileSystemProvider.ts
│ │ │ ├── node/
│ │ │ │ ├── diskFileSystemProvider.ts
│ │ │ │ ├── files.ts
│ │ │ │ └── watcher/
│ │ │ │ ├── nodejs/
│ │ │ │ │ └── watcherService.ts
│ │ │ │ ├── nsfw/
│ │ │ │ │ ├── nsfwWatcherService.ts
│ │ │ │ │ ├── test/
│ │ │ │ │ │ └── nsfwWatcherService.test.ts
│ │ │ │ │ ├── watcher.ts
│ │ │ │ │ ├── watcherApp.ts
│ │ │ │ │ ├── watcherIpc.ts
│ │ │ │ │ └── watcherService.ts
│ │ │ │ ├── unix/
│ │ │ │ │ ├── chokidarWatcherService.ts
│ │ │ │ │ ├── test/
│ │ │ │ │ │ └── chockidarWatcherService.test.ts
│ │ │ │ │ ├── watcher.ts
│ │ │ │ │ ├── watcherApp.ts
│ │ │ │ │ ├── watcherIpc.ts
│ │ │ │ │ └── watcherService.ts
│ │ │ │ ├── watcher.ts
│ │ │ │ └── win32/
│ │ │ │ ├── CodeHelper.md
│ │ │ │ ├── csharpWatcherService.ts
│ │ │ │ └── watcherService.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ └── fileService.test.ts
│ │ │ ├── common/
│ │ │ │ └── nullFileSystemProvider.ts
│ │ │ ├── files.test.ts
│ │ │ └── node/
│ │ │ ├── diskFileService.test.ts
│ │ │ ├── fixtures/
│ │ │ │ ├── resolver/
│ │ │ │ │ ├── examples/
│ │ │ │ │ │ ├── company.js
│ │ │ │ │ │ ├── conway.js
│ │ │ │ │ │ ├── employee.js
│ │ │ │ │ │ └── small.js
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── other/
│ │ │ │ │ │ └── deep/
│ │ │ │ │ │ ├── company.js
│ │ │ │ │ │ ├── conway.js
│ │ │ │ │ │ ├── employee.js
│ │ │ │ │ │ └── small.js
│ │ │ │ │ └── site.css
│ │ │ │ └── service/
│ │ │ │ ├── binary.txt
│ │ │ │ ├── deep/
│ │ │ │ │ ├── company.js
│ │ │ │ │ ├── conway.js
│ │ │ │ │ ├── employee.js
│ │ │ │ │ └── small.js
│ │ │ │ ├── index.html
│ │ │ │ ├── lorem.txt
│ │ │ │ ├── small.txt
│ │ │ │ ├── small_umlaut.txt
│ │ │ │ ├── some_utf16le.css
│ │ │ │ └── some_utf8_bom.txt
│ │ │ └── normalizer.test.ts
│ │ ├── instantiation/
│ │ │ ├── common/
│ │ │ │ ├── descriptors.ts
│ │ │ │ ├── extensions.ts
│ │ │ │ ├── graph.ts
│ │ │ │ ├── instantiation.ts
│ │ │ │ ├── instantiationService.ts
│ │ │ │ └── serviceCollection.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ ├── graph.test.ts
│ │ │ ├── instantiationService.test.ts
│ │ │ └── instantiationServiceMock.ts
│ │ ├── ipc/
│ │ │ ├── electron-browser/
│ │ │ │ ├── mainProcessService.ts
│ │ │ │ └── sharedProcessService.ts
│ │ │ └── electron-main/
│ │ │ └── sharedProcessMainService.ts
│ │ ├── issue/
│ │ │ ├── electron-main/
│ │ │ │ └── issueMainService.ts
│ │ │ └── node/
│ │ │ └── issue.ts
│ │ ├── jsonschemas/
│ │ │ └── common/
│ │ │ └── jsonContributionRegistry.ts
│ │ ├── keybinding/
│ │ │ ├── common/
│ │ │ │ ├── abstractKeybindingService.ts
│ │ │ │ ├── baseResolvedKeybinding.ts
│ │ │ │ ├── keybinding.ts
│ │ │ │ ├── keybindingResolver.ts
│ │ │ │ ├── keybindingsRegistry.ts
│ │ │ │ ├── resolvedKeybindingItem.ts
│ │ │ │ └── usLayoutResolvedKeybinding.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ ├── abstractKeybindingService.test.ts
│ │ │ ├── keybindingLabels.test.ts
│ │ │ ├── keybindingResolver.test.ts
│ │ │ └── mockKeybindingService.ts
│ │ ├── label/
│ │ │ └── common/
│ │ │ └── label.ts
│ │ ├── launch/
│ │ │ ├── common/
│ │ │ │ └── launch.ts
│ │ │ └── electron-main/
│ │ │ └── launchMainService.ts
│ │ ├── layout/
│ │ │ └── browser/
│ │ │ └── layoutService.ts
│ │ ├── lifecycle/
│ │ │ ├── common/
│ │ │ │ ├── lifecycle.ts
│ │ │ │ └── lifecycleService.ts
│ │ │ └── electron-main/
│ │ │ └── lifecycleMainService.ts
│ │ ├── list/
│ │ │ └── browser/
│ │ │ └── listService.ts
│ │ ├── localizations/
│ │ │ ├── common/
│ │ │ │ └── localizations.ts
│ │ │ └── node/
│ │ │ └── localizations.ts
│ │ ├── log/
│ │ │ ├── common/
│ │ │ │ ├── bufferLog.ts
│ │ │ │ ├── fileLogService.ts
│ │ │ │ ├── log.ts
│ │ │ │ └── logIpc.ts
│ │ │ └── node/
│ │ │ ├── loggerService.ts
│ │ │ └── spdlogService.ts
│ │ ├── markers/
│ │ │ ├── common/
│ │ │ │ ├── markerService.ts
│ │ │ │ └── markers.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── markerService.test.ts
│ │ ├── menubar/
│ │ │ ├── electron-main/
│ │ │ │ ├── menubar.ts
│ │ │ │ └── menubarMainService.ts
│ │ │ └── node/
│ │ │ └── menubar.ts
│ │ ├── notification/
│ │ │ ├── common/
│ │ │ │ └── notification.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── testNotificationService.ts
│ │ ├── opener/
│ │ │ └── common/
│ │ │ └── opener.ts
│ │ ├── product/
│ │ │ └── common/
│ │ │ ├── product.ts
│ │ │ └── productService.ts
│ │ ├── progress/
│ │ │ └── common/
│ │ │ └── progress.ts
│ │ ├── quickOpen/
│ │ │ └── common/
│ │ │ └── quickOpen.ts
│ │ ├── quickinput/
│ │ │ └── common/
│ │ │ └── quickInput.ts
│ │ ├── registry/
│ │ │ ├── common/
│ │ │ │ └── platform.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── platform.test.ts
│ │ ├── remote/
│ │ │ ├── browser/
│ │ │ │ ├── browserSocketFactory.ts
│ │ │ │ └── remoteAuthorityResolverService.ts
│ │ │ ├── common/
│ │ │ │ ├── remoteAgentConnection.ts
│ │ │ │ ├── remoteAgentEnvironment.ts
│ │ │ │ ├── remoteAgentFileSystemChannel.ts
│ │ │ │ ├── remoteAuthorityResolver.ts
│ │ │ │ ├── remoteHosts.ts
│ │ │ │ ├── tunnel.ts
│ │ │ │ └── tunnelService.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── remoteAuthorityResolverService.ts
│ │ │ └── node/
│ │ │ └── nodeSocketFactory.ts
│ │ ├── request/
│ │ │ ├── browser/
│ │ │ │ └── requestService.ts
│ │ │ ├── common/
│ │ │ │ ├── request.ts
│ │ │ │ └── requestIpc.ts
│ │ │ ├── electron-main/
│ │ │ │ └── requestMainService.ts
│ │ │ └── node/
│ │ │ ├── proxy.ts
│ │ │ └── requestService.ts
│ │ ├── severityIcon/
│ │ │ └── common/
│ │ │ └── severityIcon.ts
│ │ ├── sign/
│ │ │ ├── browser/
│ │ │ │ └── signService.ts
│ │ │ ├── common/
│ │ │ │ └── sign.ts
│ │ │ └── node/
│ │ │ └── signService.ts
│ │ ├── state/
│ │ │ ├── node/
│ │ │ │ ├── state.ts
│ │ │ │ └── stateService.ts
│ │ │ └── test/
│ │ │ └── node/
│ │ │ └── state.test.ts
│ │ ├── storage/
│ │ │ ├── browser/
│ │ │ │ └── storageService.ts
│ │ │ ├── common/
│ │ │ │ └── storage.ts
│ │ │ ├── node/
│ │ │ │ ├── storageIpc.ts
│ │ │ │ ├── storageMainService.ts
│ │ │ │ └── storageService.ts
│ │ │ └── test/
│ │ │ ├── electron-browser/
│ │ │ │ └── storage.test.ts
│ │ │ └── node/
│ │ │ └── storageService.test.ts
│ │ ├── telemetry/
│ │ │ ├── browser/
│ │ │ │ ├── errorTelemetry.ts
│ │ │ │ └── workbenchCommonProperties.ts
│ │ │ ├── common/
│ │ │ │ ├── errorTelemetry.ts
│ │ │ │ ├── gdprTypings.ts
│ │ │ │ ├── telemetry.ts
│ │ │ │ ├── telemetryService.ts
│ │ │ │ └── telemetryUtils.ts
│ │ │ ├── node/
│ │ │ │ ├── appInsightsAppender.ts
│ │ │ │ ├── commonProperties.ts
│ │ │ │ ├── errorTelemetry.ts
│ │ │ │ ├── telemetry.ts
│ │ │ │ ├── telemetryIpc.ts
│ │ │ │ └── workbenchCommonProperties.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ └── commonProperties.test.ts
│ │ │ └── electron-browser/
│ │ │ ├── appInsightsAppender.test.ts
│ │ │ ├── commonProperties.test.ts
│ │ │ └── telemetryService.test.ts
│ │ ├── theme/
│ │ │ ├── common/
│ │ │ │ ├── colorRegistry.ts
│ │ │ │ ├── styler.ts
│ │ │ │ └── themeService.ts
│ │ │ ├── electron-main/
│ │ │ │ └── themeMainService.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── testThemeService.ts
│ │ ├── update/
│ │ │ ├── common/
│ │ │ │ ├── update.config.contribution.ts
│ │ │ │ └── update.ts
│ │ │ └── electron-main/
│ │ │ ├── abstractUpdateService.ts
│ │ │ ├── updateIpc.ts
│ │ │ ├── updateService.darwin.ts
│ │ │ ├── updateService.linux.ts
│ │ │ ├── updateService.snap.ts
│ │ │ └── updateService.win32.ts
│ │ ├── url/
│ │ │ ├── common/
│ │ │ │ ├── url.ts
│ │ │ │ ├── urlIpc.ts
│ │ │ │ └── urlService.ts
│ │ │ ├── electron-main/
│ │ │ │ └── electronUrlListener.ts
│ │ │ └── node/
│ │ │ └── urlService.ts
│ │ ├── userDataSync/
│ │ │ └── common/
│ │ │ ├── extensionsSync.ts
│ │ │ ├── settingsSync.ts
│ │ │ ├── settingsSyncIpc.ts
│ │ │ ├── userDataSync.ts
│ │ │ ├── userDataSyncIpc.ts
│ │ │ ├── userDataSyncLog.ts
│ │ │ ├── userDataSyncService.ts
│ │ │ └── userDataSyncStoreService.ts
│ │ ├── windows/
│ │ │ ├── common/
│ │ │ │ └── windows.ts
│ │ │ ├── electron-main/
│ │ │ │ ├── windows.ts
│ │ │ │ ├── windowsMainService.ts
│ │ │ │ └── windowsStateStorage.ts
│ │ │ ├── node/
│ │ │ │ └── window.ts
│ │ │ └── test/
│ │ │ └── node/
│ │ │ └── window.test.ts
│ │ ├── workspace/
│ │ │ ├── common/
│ │ │ │ └── workspace.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ ├── testWorkspace.ts
│ │ │ └── workspace.test.ts
│ │ └── workspaces/
│ │ ├── common/
│ │ │ └── workspaces.ts
│ │ ├── electron-main/
│ │ │ ├── workspacesHistoryMainService.ts
│ │ │ ├── workspacesMainService.ts
│ │ │ └── workspacesService.ts
│ │ └── test/
│ │ └── electron-main/
│ │ ├── workspacesHistoryStorage.test.ts
│ │ └── workspacesMainService.test.ts
│ ├── vscode.d.ts
│ ├── vscode.proposed.d.ts
│ └── workbench/
│ ├── api/
│ │ ├── browser/
│ │ │ ├── extensionHost.contribution.ts
│ │ │ ├── mainThreadClipboard.ts
│ │ │ ├── mainThreadCodeInsets.ts
│ │ │ ├── mainThreadCommands.ts
│ │ │ ├── mainThreadComments.ts
│ │ │ ├── mainThreadConfiguration.ts
│ │ │ ├── mainThreadConsole.ts
│ │ │ ├── mainThreadDebugService.ts
│ │ │ ├── mainThreadDecorations.ts
│ │ │ ├── mainThreadDiagnostics.ts
│ │ │ ├── mainThreadDialogs.ts
│ │ │ ├── mainThreadDocumentContentProviders.ts
│ │ │ ├── mainThreadDocuments.ts
│ │ │ ├── mainThreadDocumentsAndEditors.ts
│ │ │ ├── mainThreadDownloadService.ts
│ │ │ ├── mainThreadEditor.ts
│ │ │ ├── mainThreadEditors.ts
│ │ │ ├── mainThreadErrors.ts
│ │ │ ├── mainThreadExtensionService.ts
│ │ │ ├── mainThreadFileSystem.ts
│ │ │ ├── mainThreadFileSystemEventService.ts
│ │ │ ├── mainThreadKeytar.ts
│ │ │ ├── mainThreadLabelService.ts
│ │ │ ├── mainThreadLanguageFeatures.ts
│ │ │ ├── mainThreadLanguages.ts
│ │ │ ├── mainThreadLogService.ts
│ │ │ ├── mainThreadMessageService.ts
│ │ │ ├── mainThreadOutputService.ts
│ │ │ ├── mainThreadProgress.ts
│ │ │ ├── mainThreadQuickOpen.ts
│ │ │ ├── mainThreadSCM.ts
│ │ │ ├── mainThreadSaveParticipant.ts
│ │ │ ├── mainThreadSearch.ts
│ │ │ ├── mainThreadStatusBar.ts
│ │ │ ├── mainThreadStorage.ts
│ │ │ ├── mainThreadTask.ts
│ │ │ ├── mainThreadTelemetry.ts
│ │ │ ├── mainThreadTerminalService.ts
│ │ │ ├── mainThreadTreeViews.ts
│ │ │ ├── mainThreadUrls.ts
│ │ │ ├── mainThreadWebview.ts
│ │ │ ├── mainThreadWindow.ts
│ │ │ ├── mainThreadWorkspace.ts
│ │ │ └── viewsExtensionPoint.ts
│ │ ├── common/
│ │ │ ├── apiCommands.ts
│ │ │ ├── configurationExtensionPoint.ts
│ │ │ ├── extHost.api.impl.ts
│ │ │ ├── extHost.protocol.ts
│ │ │ ├── extHostApiCommands.ts
│ │ │ ├── extHostClipboard.ts
│ │ │ ├── extHostCodeInsets.ts
│ │ │ ├── extHostCommands.ts
│ │ │ ├── extHostComments.ts
│ │ │ ├── extHostConfiguration.ts
│ │ │ ├── extHostCustomers.ts
│ │ │ ├── extHostDebugService.ts
│ │ │ ├── extHostDecorations.ts
│ │ │ ├── extHostDiagnostics.ts
│ │ │ ├── extHostDialogs.ts
│ │ │ ├── extHostDocumentContentProviders.ts
│ │ │ ├── extHostDocumentData.ts
│ │ │ ├── extHostDocumentSaveParticipant.ts
│ │ │ ├── extHostDocuments.ts
│ │ │ ├── extHostDocumentsAndEditors.ts
│ │ │ ├── extHostExtensionActivator.ts
│ │ │ ├── extHostExtensionService.ts
│ │ │ ├── extHostFileSystem.ts
│ │ │ ├── extHostFileSystemEventService.ts
│ │ │ ├── extHostInitDataService.ts
│ │ │ ├── extHostLabelService.ts
│ │ │ ├── extHostLanguageFeatures.ts
│ │ │ ├── extHostLanguages.ts
│ │ │ ├── extHostMemento.ts
│ │ │ ├── extHostMessageService.ts
│ │ │ ├── extHostOutput.ts
│ │ │ ├── extHostProgress.ts
│ │ │ ├── extHostQuickOpen.ts
│ │ │ ├── extHostRequireInterceptor.ts
│ │ │ ├── extHostRpcService.ts
│ │ │ ├── extHostSCM.ts
│ │ │ ├── extHostSearch.ts
│ │ │ ├── extHostStatusBar.ts
│ │ │ ├── extHostStorage.ts
│ │ │ ├── extHostStoragePaths.ts
│ │ │ ├── extHostTask.ts
│ │ │ ├── extHostTerminalService.ts
│ │ │ ├── extHostTextEditor.ts
│ │ │ ├── extHostTextEditors.ts
│ │ │ ├── extHostTreeViews.ts
│ │ │ ├── extHostTypeConverters.ts
│ │ │ ├── extHostTypes.ts
│ │ │ ├── extHostUriTransformerService.ts
│ │ │ ├── extHostUrls.ts
│ │ │ ├── extHostWebview.ts
│ │ │ ├── extHostWindow.ts
│ │ │ ├── extHostWorkspace.ts
│ │ │ ├── jsonValidationExtensionPoint.ts
│ │ │ ├── menusExtensionPoint.ts
│ │ │ └── shared/
│ │ │ ├── editor.ts
│ │ │ ├── tasks.ts
│ │ │ └── webview.ts
│ │ ├── node/
│ │ │ ├── extHost.services.ts
│ │ │ ├── extHostCLIServer.ts
│ │ │ ├── extHostDebugService.ts
│ │ │ ├── extHostDownloadService.ts
│ │ │ ├── extHostExtensionService.ts
│ │ │ ├── extHostLogService.ts
│ │ │ ├── extHostOutputService.ts
│ │ │ ├── extHostSearch.ts
│ │ │ ├── extHostStoragePaths.ts
│ │ │ ├── extHostTask.ts
│ │ │ └── extHostTerminalService.ts
│ │ └── worker/
│ │ ├── extHostExtensionService.ts
│ │ └── extHostLogService.ts
│ ├── browser/
│ │ ├── actions/
│ │ │ ├── developerActions.ts
│ │ │ ├── helpActions.ts
│ │ │ ├── layoutActions.ts
│ │ │ ├── listCommands.ts
│ │ │ ├── media/
│ │ │ │ ├── actions.css
│ │ │ │ └── screencast.css
│ │ │ ├── navigationActions.ts
│ │ │ ├── textInputActions.ts
│ │ │ ├── windowActions.ts
│ │ │ ├── workspaceActions.ts
│ │ │ └── workspaceCommands.ts
│ │ ├── actions.ts
│ │ ├── composite.ts
│ │ ├── contextkeys.ts
│ │ ├── dnd.ts
│ │ ├── editor.ts
│ │ ├── labels.ts
│ │ ├── layout.ts
│ │ ├── media/
│ │ │ ├── part.css
│ │ │ └── style.css
│ │ ├── panel.ts
│ │ ├── part.ts
│ │ ├── parts/
│ │ │ ├── activitybar/
│ │ │ │ ├── activitybarActions.ts
│ │ │ │ ├── activitybarPart.ts
│ │ │ │ └── media/
│ │ │ │ ├── activityaction.css
│ │ │ │ └── activitybarpart.css
│ │ │ ├── compositeBar.ts
│ │ │ ├── compositeBarActions.ts
│ │ │ ├── compositePart.ts
│ │ │ ├── editor/
│ │ │ │ ├── baseEditor.ts
│ │ │ │ ├── binaryDiffEditor.ts
│ │ │ │ ├── binaryEditor.ts
│ │ │ │ ├── breadcrumbs.ts
│ │ │ │ ├── breadcrumbsControl.ts
│ │ │ │ ├── breadcrumbsModel.ts
│ │ │ │ ├── breadcrumbsPicker.ts
│ │ │ │ ├── editor.contribution.ts
│ │ │ │ ├── editor.ts
│ │ │ │ ├── editorActions.ts
│ │ │ │ ├── editorCommands.ts
│ │ │ │ ├── editorControl.ts
│ │ │ │ ├── editorDropTarget.ts
│ │ │ │ ├── editorGroupView.ts
│ │ │ │ ├── editorPart.ts
│ │ │ │ ├── editorPicker.ts
│ │ │ │ ├── editorStatus.ts
│ │ │ │ ├── editorWidgets.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── breadcrumbscontrol.css
│ │ │ │ │ ├── editordroptarget.css
│ │ │ │ │ ├── editorgroupview.css
│ │ │ │ │ ├── editorpicker.css
│ │ │ │ │ ├── editorstatus.css
│ │ │ │ │ ├── notabstitlecontrol.css
│ │ │ │ │ ├── resourceviewer.css
│ │ │ │ │ ├── tabstitlecontrol.css
│ │ │ │ │ └── titlecontrol.css
│ │ │ │ ├── noTabsTitleControl.ts
│ │ │ │ ├── rangeDecorations.ts
│ │ │ │ ├── resourceViewer.ts
│ │ │ │ ├── sideBySideEditor.ts
│ │ │ │ ├── tabsTitleControl.ts
│ │ │ │ ├── textDiffEditor.ts
│ │ │ │ ├── textEditor.ts
│ │ │ │ ├── textResourceEditor.ts
│ │ │ │ └── titleControl.ts
│ │ │ ├── media/
│ │ │ │ └── compositepart.css
│ │ │ ├── notifications/
│ │ │ │ ├── media/
│ │ │ │ │ ├── notificationsActions.css
│ │ │ │ │ ├── notificationsCenter.css
│ │ │ │ │ ├── notificationsList.css
│ │ │ │ │ └── notificationsToasts.css
│ │ │ │ ├── notificationsActions.ts
│ │ │ │ ├── notificationsAlerts.ts
│ │ │ │ ├── notificationsCenter.ts
│ │ │ │ ├── notificationsCommands.ts
│ │ │ │ ├── notificationsList.ts
│ │ │ │ ├── notificationsStatus.ts
│ │ │ │ ├── notificationsToasts.ts
│ │ │ │ └── notificationsViewer.ts
│ │ │ ├── panel/
│ │ │ │ ├── media/
│ │ │ │ │ └── panelpart.css
│ │ │ │ ├── panelActions.ts
│ │ │ │ └── panelPart.ts
│ │ │ ├── quickinput/
│ │ │ │ ├── media/
│ │ │ │ │ └── quickInput.css
│ │ │ │ ├── quickInput.ts
│ │ │ │ ├── quickInputActions.ts
│ │ │ │ ├── quickInputBox.ts
│ │ │ │ ├── quickInputList.ts
│ │ │ │ └── quickInputUtils.ts
│ │ │ ├── quickopen/
│ │ │ │ ├── media/
│ │ │ │ │ └── quickopen.css
│ │ │ │ ├── quickOpenActions.ts
│ │ │ │ ├── quickOpenController.ts
│ │ │ │ └── quickopen.ts
│ │ │ ├── sidebar/
│ │ │ │ ├── media/
│ │ │ │ │ └── sidebarpart.css
│ │ │ │ └── sidebarPart.ts
│ │ │ ├── statusbar/
│ │ │ │ ├── media/
│ │ │ │ │ └── statusbarpart.css
│ │ │ │ └── statusbarPart.ts
│ │ │ ├── titlebar/
│ │ │ │ ├── media/
│ │ │ │ │ └── titlebarpart.css
│ │ │ │ ├── menubarControl.ts
│ │ │ │ └── titlebarPart.ts
│ │ │ └── views/
│ │ │ ├── customView.ts
│ │ │ ├── media/
│ │ │ │ ├── panelviewlet.css
│ │ │ │ └── views.css
│ │ │ ├── panelViewlet.ts
│ │ │ ├── views.ts
│ │ │ └── viewsViewlet.ts
│ │ ├── quickopen.ts
│ │ ├── style.ts
│ │ ├── viewlet.ts
│ │ ├── web.main.ts
│ │ ├── workbench.contribution.ts
│ │ └── workbench.ts
│ ├── buildfile.desktop.js
│ ├── buildfile.web.js
│ ├── common/
│ │ ├── actions.ts
│ │ ├── activity.ts
│ │ ├── component.ts
│ │ ├── composite.ts
│ │ ├── contributions.ts
│ │ ├── editor/
│ │ │ ├── binaryEditorModel.ts
│ │ │ ├── dataUriEditorInput.ts
│ │ │ ├── diffEditorInput.ts
│ │ │ ├── diffEditorModel.ts
│ │ │ ├── editorGroup.ts
│ │ │ ├── resourceEditorInput.ts
│ │ │ ├── resourceEditorModel.ts
│ │ │ ├── textDiffEditorModel.ts
│ │ │ ├── textEditorModel.ts
│ │ │ ├── untitledEditorInput.ts
│ │ │ └── untitledEditorModel.ts
│ │ ├── editor.ts
│ │ ├── memento.ts
│ │ ├── notifications.ts
│ │ ├── panel.ts
│ │ ├── resources.ts
│ │ ├── theme.ts
│ │ ├── viewlet.ts
│ │ └── views.ts
│ ├── contrib/
│ │ ├── backup/
│ │ │ └── common/
│ │ │ ├── backup.contribution.ts
│ │ │ ├── backupModelTracker.ts
│ │ │ └── backupRestorer.ts
│ │ ├── callHierarchy/
│ │ │ └── browser/
│ │ │ ├── callHierarchy.contribution.ts
│ │ │ ├── callHierarchy.ts
│ │ │ ├── callHierarchyPeek.ts
│ │ │ ├── callHierarchyTree.ts
│ │ │ └── media/
│ │ │ └── callHierarchy.css
│ │ ├── cli/
│ │ │ └── node/
│ │ │ └── cli.contribution.ts
│ │ ├── codeEditor/
│ │ │ ├── browser/
│ │ │ │ ├── accessibility/
│ │ │ │ │ ├── accessibility.css
│ │ │ │ │ └── accessibility.ts
│ │ │ │ ├── codeEditor.contribution.ts
│ │ │ │ ├── diffEditorHelper.ts
│ │ │ │ ├── find/
│ │ │ │ │ ├── simpleFindWidget.css
│ │ │ │ │ └── simpleFindWidget.ts
│ │ │ │ ├── inspectKeybindings.ts
│ │ │ │ ├── inspectTMScopes/
│ │ │ │ │ ├── inspectTMScopes.css
│ │ │ │ │ └── inspectTMScopes.ts
│ │ │ │ ├── languageConfigurationExtensionPoint.ts
│ │ │ │ ├── largeFileOptimizations.ts
│ │ │ │ ├── menuPreventer.ts
│ │ │ │ ├── selectionClipboard.ts
│ │ │ │ ├── simpleEditorOptions.ts
│ │ │ │ ├── suggestEnabledInput/
│ │ │ │ │ ├── suggestEnabledInput.css
│ │ │ │ │ └── suggestEnabledInput.ts
│ │ │ │ ├── toggleMinimap.ts
│ │ │ │ ├── toggleMultiCursorModifier.ts
│ │ │ │ ├── toggleRenderControlCharacter.ts
│ │ │ │ ├── toggleRenderWhitespace.ts
│ │ │ │ ├── toggleWordWrap.ts
│ │ │ │ └── workbenchReferenceSearch.ts
│ │ │ └── electron-browser/
│ │ │ ├── codeEditor.contribution.ts
│ │ │ └── sleepResumeRepaintMinimap.ts
│ │ ├── comments/
│ │ │ ├── browser/
│ │ │ │ ├── commentFormActions.ts
│ │ │ │ ├── commentGlyphWidget.ts
│ │ │ │ ├── commentMenus.ts
│ │ │ │ ├── commentNode.ts
│ │ │ │ ├── commentService.ts
│ │ │ │ ├── commentThreadWidget.ts
│ │ │ │ ├── comments.contribution.ts
│ │ │ │ ├── commentsEditorContribution.ts
│ │ │ │ ├── commentsPanel.ts
│ │ │ │ ├── commentsTreeViewer.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── panel.css
│ │ │ │ │ └── review.css
│ │ │ │ ├── reactionsAction.ts
│ │ │ │ └── simpleCommentEditor.ts
│ │ │ └── common/
│ │ │ ├── commentContextKeys.ts
│ │ │ ├── commentModel.ts
│ │ │ └── commentThreadWidget.ts
│ │ ├── configExporter/
│ │ │ └── node/
│ │ │ ├── configurationExportHelper.contribution.ts
│ │ │ └── configurationExportHelper.ts
│ │ ├── customEditor/
│ │ │ ├── browser/
│ │ │ │ ├── commands.ts
│ │ │ │ ├── customEditorInput.ts
│ │ │ │ ├── customEditorInputFactory.ts
│ │ │ │ ├── customEditors.ts
│ │ │ │ ├── extensionPoint.ts
│ │ │ │ └── webviewEditor.contribution.ts
│ │ │ └── common/
│ │ │ └── customEditor.ts
│ │ ├── debug/
│ │ │ ├── browser/
│ │ │ │ ├── baseDebugView.ts
│ │ │ │ ├── breakpointEditorContribution.ts
│ │ │ │ ├── breakpointWidget.ts
│ │ │ │ ├── breakpointsView.ts
│ │ │ │ ├── callStackView.ts
│ │ │ │ ├── debug.contribution.ts
│ │ │ │ ├── debugANSIHandling.ts
│ │ │ │ ├── debugActionViewItems.ts
│ │ │ │ ├── debugActions.ts
│ │ │ │ ├── debugCallStackContribution.ts
│ │ │ │ ├── debugCommands.ts
│ │ │ │ ├── debugConfigurationManager.ts
│ │ │ │ ├── debugEditorActions.ts
│ │ │ │ ├── debugEditorContribution.ts
│ │ │ │ ├── debugHover.ts
│ │ │ │ ├── debugQuickOpen.ts
│ │ │ │ ├── debugService.ts
│ │ │ │ ├── debugSession.ts
│ │ │ │ ├── debugStatus.ts
│ │ │ │ ├── debugToolBar.ts
│ │ │ │ ├── debugViewlet.ts
│ │ │ │ ├── exceptionWidget.ts
│ │ │ │ ├── extensionHostDebugService.ts
│ │ │ │ ├── linkDetector.ts
│ │ │ │ ├── loadedScriptsView.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── breakpointWidget.css
│ │ │ │ │ ├── debug.contribution.css
│ │ │ │ │ ├── debugHover.css
│ │ │ │ │ ├── debugToolBar.css
│ │ │ │ │ ├── debugViewlet.css
│ │ │ │ │ ├── exceptionWidget.css
│ │ │ │ │ └── repl.css
│ │ │ │ ├── rawDebugSession.ts
│ │ │ │ ├── repl.ts
│ │ │ │ ├── statusbarColorProvider.ts
│ │ │ │ ├── variablesView.ts
│ │ │ │ └── watchExpressionsView.ts
│ │ │ ├── common/
│ │ │ │ ├── abstractDebugAdapter.ts
│ │ │ │ ├── debug.ts
│ │ │ │ ├── debugContentProvider.ts
│ │ │ │ ├── debugModel.ts
│ │ │ │ ├── debugProtocol.d.ts
│ │ │ │ ├── debugSchemas.ts
│ │ │ │ ├── debugSource.ts
│ │ │ │ ├── debugUtils.ts
│ │ │ │ ├── debugViewModel.ts
│ │ │ │ ├── debugger.ts
│ │ │ │ └── replModel.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── extensionHostDebugService.ts
│ │ │ ├── node/
│ │ │ │ ├── debugAdapter.ts
│ │ │ │ ├── debugHelperService.ts
│ │ │ │ ├── telemetryApp.ts
│ │ │ │ └── terminals.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ ├── baseDebugView.test.ts
│ │ │ │ ├── debugANSIHandling.test.ts
│ │ │ │ ├── debugModel.test.ts
│ │ │ │ └── linkDetector.test.ts
│ │ │ ├── common/
│ │ │ │ ├── debugSource.test.ts
│ │ │ │ ├── debugUtils.test.ts
│ │ │ │ ├── debugViewModel.test.ts
│ │ │ │ └── mockDebug.ts
│ │ │ └── node/
│ │ │ └── debugger.test.ts
│ │ ├── emmet/
│ │ │ ├── browser/
│ │ │ │ ├── actions/
│ │ │ │ │ ├── expandAbbreviation.ts
│ │ │ │ │ └── showEmmetCommands.ts
│ │ │ │ ├── emmet.contribution.ts
│ │ │ │ └── emmetActions.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ └── emmetAction.test.ts
│ │ ├── experiments/
│ │ │ ├── browser/
│ │ │ │ ├── experimentalPrompt.ts
│ │ │ │ └── experiments.contribution.ts
│ │ │ ├── common/
│ │ │ │ └── experimentService.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ ├── experimentService.test.ts
│ │ │ └── experimentalPrompts.test.ts
│ │ ├── extensions/
│ │ │ ├── browser/
│ │ │ │ ├── extensionEditor.ts
│ │ │ │ ├── extensionTipsService.ts
│ │ │ │ ├── extensions.contribution.ts
│ │ │ │ ├── extensionsActions.ts
│ │ │ │ ├── extensionsActivationProgress.ts
│ │ │ │ ├── extensionsDependencyChecker.ts
│ │ │ │ ├── extensionsList.ts
│ │ │ │ ├── extensionsQuickOpen.ts
│ │ │ │ ├── extensionsViewer.ts
│ │ │ │ ├── extensionsViewlet.ts
│ │ │ │ ├── extensionsViews.ts
│ │ │ │ ├── extensionsWidgets.ts
│ │ │ │ ├── extensionsWorkbenchService.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── extensionActions.css
│ │ │ │ │ ├── extensionEditor.css
│ │ │ │ │ ├── extensions.css
│ │ │ │ │ ├── extensionsViewlet.css
│ │ │ │ │ └── extensionsWidgets.css
│ │ │ │ └── remoteExtensionsInstaller.ts
│ │ │ ├── common/
│ │ │ │ ├── extensionQuery.ts
│ │ │ │ ├── extensions.ts
│ │ │ │ ├── extensionsFileTemplate.ts
│ │ │ │ ├── extensionsInput.ts
│ │ │ │ └── extensionsUtils.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── extensionProfileService.ts
│ │ │ │ ├── extensions.contribution.ts
│ │ │ │ ├── extensionsActions.ts
│ │ │ │ ├── extensionsAutoProfiler.ts
│ │ │ │ ├── extensionsSlowActions.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── runtimeExtensionsEditor.css
│ │ │ │ ├── runtimeExtensionsEditor.ts
│ │ │ │ └── runtimeExtensionsInput.ts
│ │ │ └── test/
│ │ │ ├── common/
│ │ │ │ └── extensionQuery.test.ts
│ │ │ └── electron-browser/
│ │ │ ├── extensionsActions.test.ts
│ │ │ ├── extensionsTipsService.test.ts
│ │ │ ├── extensionsViews.test.ts
│ │ │ └── extensionsWorkbenchService.test.ts
│ │ ├── externalTerminal/
│ │ │ ├── browser/
│ │ │ │ └── externalTerminal.contribution.ts
│ │ │ ├── common/
│ │ │ │ └── externalTerminal.ts
│ │ │ ├── node/
│ │ │ │ ├── TerminalHelper.scpt
│ │ │ │ ├── externalTerminalService.ts
│ │ │ │ └── iTermHelper.scpt
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ └── externalTerminalService.test.ts
│ │ ├── feedback/
│ │ │ └── browser/
│ │ │ ├── feedback.contribution.ts
│ │ │ ├── feedback.ts
│ │ │ ├── feedbackStatusbarItem.ts
│ │ │ └── media/
│ │ │ └── feedback.css
│ │ ├── files/
│ │ │ ├── browser/
│ │ │ │ ├── editors/
│ │ │ │ │ ├── binaryFileEditor.ts
│ │ │ │ │ ├── fileEditorTracker.ts
│ │ │ │ │ └── textFileEditor.ts
│ │ │ │ ├── explorerViewlet.ts
│ │ │ │ ├── fileActions.contribution.ts
│ │ │ │ ├── fileActions.ts
│ │ │ │ ├── fileCommands.ts
│ │ │ │ ├── files.contribution.ts
│ │ │ │ ├── files.ts
│ │ │ │ ├── files.web.contribution.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── explorerviewlet.css
│ │ │ │ │ └── fileactions.css
│ │ │ │ ├── saveErrorHandler.ts
│ │ │ │ └── views/
│ │ │ │ ├── emptyView.ts
│ │ │ │ ├── explorerDecorationsProvider.ts
│ │ │ │ ├── explorerView.ts
│ │ │ │ ├── explorerViewer.ts
│ │ │ │ └── openEditorsView.ts
│ │ │ ├── common/
│ │ │ │ ├── dirtyFilesTracker.ts
│ │ │ │ ├── editors/
│ │ │ │ │ └── fileEditorInput.ts
│ │ │ │ ├── explorerModel.ts
│ │ │ │ ├── explorerService.ts
│ │ │ │ ├── files.ts
│ │ │ │ └── workspaceWatcher.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── dirtyFilesTracker.ts
│ │ │ │ ├── fileActions.contribution.ts
│ │ │ │ ├── fileCommands.ts
│ │ │ │ ├── files.contribution.ts
│ │ │ │ └── textFileEditor.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ ├── fileEditorInput.test.ts
│ │ │ │ └── fileEditorTracker.test.ts
│ │ │ ├── common/
│ │ │ │ └── fileOnDiskProvider.test.ts
│ │ │ └── electron-browser/
│ │ │ ├── explorerModel.test.ts
│ │ │ └── fileActions.test.ts
│ │ ├── format/
│ │ │ └── browser/
│ │ │ ├── format.contribution.ts
│ │ │ ├── formatActionsMultiple.ts
│ │ │ ├── formatActionsNone.ts
│ │ │ └── showExtensionQuery.ts
│ │ ├── issue/
│ │ │ └── electron-browser/
│ │ │ ├── issue.contribution.ts
│ │ │ ├── issue.ts
│ │ │ ├── issueActions.ts
│ │ │ └── issueService.ts
│ │ ├── localizations/
│ │ │ └── browser/
│ │ │ ├── localizations.contribution.ts
│ │ │ ├── localizationsActions.ts
│ │ │ └── minimalTranslations.ts
│ │ ├── logs/
│ │ │ ├── common/
│ │ │ │ ├── logConstants.ts
│ │ │ │ ├── logs.contribution.ts
│ │ │ │ ├── logsActions.ts
│ │ │ │ └── logsDataCleaner.ts
│ │ │ └── electron-browser/
│ │ │ ├── logs.contribution.ts
│ │ │ └── logsActions.ts
│ │ ├── markdown/
│ │ │ └── common/
│ │ │ └── markdownDocumentRenderer.ts
│ │ ├── markers/
│ │ │ ├── browser/
│ │ │ │ ├── constants.ts
│ │ │ │ ├── markers.contribution.ts
│ │ │ │ ├── markers.ts
│ │ │ │ ├── markersFileDecorations.ts
│ │ │ │ ├── markersFilterOptions.ts
│ │ │ │ ├── markersModel.ts
│ │ │ │ ├── markersPanel.ts
│ │ │ │ ├── markersPanelActions.ts
│ │ │ │ ├── markersTreeViewer.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── markers.css
│ │ │ │ └── messages.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ └── markersModel.test.ts
│ │ ├── outline/
│ │ │ └── browser/
│ │ │ ├── outline.contribution.ts
│ │ │ ├── outlinePanel.css
│ │ │ └── outlinePanel.ts
│ │ ├── output/
│ │ │ ├── browser/
│ │ │ │ ├── logViewer.ts
│ │ │ │ ├── output.contribution.ts
│ │ │ │ ├── outputActions.ts
│ │ │ │ ├── outputPanel.ts
│ │ │ │ └── outputServices.ts
│ │ │ ├── common/
│ │ │ │ ├── output.ts
│ │ │ │ ├── outputLinkComputer.ts
│ │ │ │ └── outputLinkProvider.ts
│ │ │ └── test/
│ │ │ └── outputLinkProvider.test.ts
│ │ ├── performance/
│ │ │ └── electron-browser/
│ │ │ ├── performance.contribution.ts
│ │ │ ├── perfviewEditor.ts
│ │ │ ├── startupProfiler.ts
│ │ │ └── startupTimings.ts
│ │ ├── preferences/
│ │ │ ├── browser/
│ │ │ │ ├── keybindingWidgets.ts
│ │ │ │ ├── keybindingsEditor.ts
│ │ │ │ ├── keybindingsEditorContribution.ts
│ │ │ │ ├── keyboardLayoutPicker.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── keybindings.css
│ │ │ │ │ ├── keybindingsEditor.css
│ │ │ │ │ ├── preferences.css
│ │ │ │ │ ├── settingsEditor2.css
│ │ │ │ │ └── settingsWidgets.css
│ │ │ │ ├── preferences.contribution.ts
│ │ │ │ ├── preferencesActions.ts
│ │ │ │ ├── preferencesEditor.ts
│ │ │ │ ├── preferencesRenderers.ts
│ │ │ │ ├── preferencesSearch.ts
│ │ │ │ ├── preferencesWidgets.ts
│ │ │ │ ├── settingsEditor2.ts
│ │ │ │ ├── settingsLayout.ts
│ │ │ │ ├── settingsTree.ts
│ │ │ │ ├── settingsTreeModels.ts
│ │ │ │ ├── settingsWidgets.ts
│ │ │ │ └── tocTree.ts
│ │ │ ├── common/
│ │ │ │ ├── preferences.ts
│ │ │ │ ├── preferencesContribution.ts
│ │ │ │ └── smartSnippetInserter.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ ├── keybindingsEditorContribution.test.ts
│ │ │ │ └── settingsTreeModels.test.ts
│ │ │ └── common/
│ │ │ └── smartSnippetInserter.test.ts
│ │ ├── quickopen/
│ │ │ └── browser/
│ │ │ ├── commandsHandler.ts
│ │ │ ├── gotoLineHandler.ts
│ │ │ ├── gotoSymbolHandler.ts
│ │ │ ├── helpHandler.ts
│ │ │ ├── quickopen.contribution.ts
│ │ │ └── viewPickerHandler.ts
│ │ ├── relauncher/
│ │ │ └── browser/
│ │ │ └── relauncher.contribution.ts
│ │ ├── remote/
│ │ │ ├── browser/
│ │ │ │ ├── remote.ts
│ │ │ │ └── remoteViewlet.css
│ │ │ ├── common/
│ │ │ │ └── remote.contribution.ts
│ │ │ └── electron-browser/
│ │ │ └── remote.contribution.ts
│ │ ├── scm/
│ │ │ ├── browser/
│ │ │ │ ├── activity.ts
│ │ │ │ ├── dirtydiffDecorator.ts
│ │ │ │ ├── mainPanel.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── dirtydiffDecorator.css
│ │ │ │ │ └── scmViewlet.css
│ │ │ │ ├── menus.ts
│ │ │ │ ├── repositoryPanel.ts
│ │ │ │ ├── scm.contribution.ts
│ │ │ │ ├── scmViewlet.ts
│ │ │ │ └── util.ts
│ │ │ └── common/
│ │ │ ├── scm.ts
│ │ │ └── scmService.ts
│ │ ├── search/
│ │ │ ├── browser/
│ │ │ │ ├── media/
│ │ │ │ │ ├── search.contribution.css
│ │ │ │ │ └── searchview.css
│ │ │ │ ├── openAnythingHandler.ts
│ │ │ │ ├── openFileHandler.ts
│ │ │ │ ├── openSymbolHandler.ts
│ │ │ │ ├── patternInputWidget.ts
│ │ │ │ ├── replaceContributions.ts
│ │ │ │ ├── replaceService.ts
│ │ │ │ ├── search.contribution.ts
│ │ │ │ ├── searchActions.ts
│ │ │ │ ├── searchPanel.ts
│ │ │ │ ├── searchResultsView.ts
│ │ │ │ ├── searchView.ts
│ │ │ │ ├── searchViewlet.ts
│ │ │ │ └── searchWidget.ts
│ │ │ ├── common/
│ │ │ │ ├── constants.ts
│ │ │ │ ├── queryBuilder.ts
│ │ │ │ ├── replace.ts
│ │ │ │ ├── search.ts
│ │ │ │ ├── searchHistoryService.ts
│ │ │ │ └── searchModel.ts
│ │ │ └── test/
│ │ │ ├── browser/
│ │ │ │ ├── mockSearchTree.ts
│ │ │ │ ├── openFileHandler.test.ts
│ │ │ │ ├── searchActions.test.ts
│ │ │ │ └── searchViewlet.test.ts
│ │ │ └── common/
│ │ │ ├── queryBuilder.test.ts
│ │ │ ├── searchModel.test.ts
│ │ │ └── searchResult.test.ts
│ │ ├── snippets/
│ │ │ ├── browser/
│ │ │ │ ├── configureSnippets.ts
│ │ │ │ ├── insertSnippet.ts
│ │ │ │ ├── snippetCompletionProvider.ts
│ │ │ │ ├── snippets.contribution.ts
│ │ │ │ ├── snippetsFile.ts
│ │ │ │ ├── snippetsService.ts
│ │ │ │ └── tabCompletion.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ ├── snippetFile.test.ts
│ │ │ ├── snippetsRegistry.test.ts
│ │ │ ├── snippetsRewrite.test.ts
│ │ │ └── snippetsService.test.ts
│ │ ├── splash/
│ │ │ └── electron-browser/
│ │ │ └── partsSplash.contribution.ts
│ │ ├── stats/
│ │ │ ├── browser/
│ │ │ │ └── workspaceStatsService.ts
│ │ │ ├── common/
│ │ │ │ └── workspaceStats.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── stats.contribution.ts
│ │ │ │ ├── workspaceStats.ts
│ │ │ │ └── workspaceStatsService.ts
│ │ │ └── test/
│ │ │ └── workspaceStats.test.ts
│ │ ├── surveys/
│ │ │ └── browser/
│ │ │ ├── languageSurveys.contribution.ts
│ │ │ └── nps.contribution.ts
│ │ ├── tasks/
│ │ │ ├── browser/
│ │ │ │ ├── abstractTaskService.ts
│ │ │ │ ├── quickOpen.ts
│ │ │ │ ├── runAutomaticTasks.ts
│ │ │ │ ├── task.contribution.ts
│ │ │ │ ├── taskQuickOpen.ts
│ │ │ │ ├── taskService.ts
│ │ │ │ └── terminalTaskSystem.ts
│ │ │ ├── common/
│ │ │ │ ├── jsonSchemaCommon.ts
│ │ │ │ ├── jsonSchema_v1.ts
│ │ │ │ ├── jsonSchema_v2.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── task.contribution.css
│ │ │ │ ├── problemCollectors.ts
│ │ │ │ ├── problemMatcher.ts
│ │ │ │ ├── taskConfiguration.ts
│ │ │ │ ├── taskDefinitionRegistry.ts
│ │ │ │ ├── taskService.ts
│ │ │ │ ├── taskSystem.ts
│ │ │ │ ├── taskTemplates.ts
│ │ │ │ └── tasks.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── taskService.ts
│ │ │ ├── node/
│ │ │ │ ├── processRunnerDetector.ts
│ │ │ │ └── processTaskSystem.ts
│ │ │ └── test/
│ │ │ ├── common/
│ │ │ │ └── problemMatcher.test.ts
│ │ │ └── electron-browser/
│ │ │ └── configuration.test.ts
│ │ ├── telemetry/
│ │ │ └── browser/
│ │ │ └── telemetry.contribution.ts
│ │ ├── terminal/
│ │ │ ├── browser/
│ │ │ │ ├── addons/
│ │ │ │ │ ├── commandTrackerAddon.ts
│ │ │ │ │ └── navigationModeAddon.ts
│ │ │ │ ├── media/
│ │ │ │ │ ├── scrollbar.css
│ │ │ │ │ ├── terminal.css
│ │ │ │ │ ├── widgets.css
│ │ │ │ │ └── xterm.css
│ │ │ │ ├── terminal.contribution.ts
│ │ │ │ ├── terminal.ts
│ │ │ │ ├── terminalActions.ts
│ │ │ │ ├── terminalCommands.ts
│ │ │ │ ├── terminalConfigHelper.ts
│ │ │ │ ├── terminalFindWidget.ts
│ │ │ │ ├── terminalInstance.ts
│ │ │ │ ├── terminalInstanceService.ts
│ │ │ │ ├── terminalLinkHandler.ts
│ │ │ │ ├── terminalNativeService.ts
│ │ │ │ ├── terminalPanel.ts
│ │ │ │ ├── terminalProcessExtHostProxy.ts
│ │ │ │ ├── terminalProcessManager.ts
│ │ │ │ ├── terminalQuickOpen.ts
│ │ │ │ ├── terminalService.ts
│ │ │ │ ├── terminalTab.ts
│ │ │ │ ├── terminalWidgetManager.ts
│ │ │ │ └── xterm-private.d.ts
│ │ │ ├── common/
│ │ │ │ ├── terminal.ts
│ │ │ │ ├── terminalColorRegistry.ts
│ │ │ │ ├── terminalEnvironment.ts
│ │ │ │ ├── terminalMenu.ts
│ │ │ │ └── terminalShellConfig.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── terminal.contribution.ts
│ │ │ │ ├── terminalInstanceService.ts
│ │ │ │ ├── terminalNativeService.ts
│ │ │ │ ├── terminalRemote.ts
│ │ │ │ └── windowsShellHelper.ts
│ │ │ ├── node/
│ │ │ │ ├── terminal.ts
│ │ │ │ ├── terminalEnvironment.ts
│ │ │ │ └── terminalProcess.ts
│ │ │ └── test/
│ │ │ ├── electron-browser/
│ │ │ │ ├── terminalColorRegistry.test.ts
│ │ │ │ ├── terminalCommandTracker.test.ts
│ │ │ │ ├── terminalConfigHelper.test.ts
│ │ │ │ └── terminalLinkHandler.test.ts
│ │ │ └── node/
│ │ │ └── terminalEnvironment.test.ts
│ │ ├── themes/
│ │ │ ├── browser/
│ │ │ │ └── themes.contribution.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ ├── fixtures/
│ │ │ │ └── foo.js
│ │ │ └── themes.test.contribution.ts
│ │ ├── update/
│ │ │ ├── browser/
│ │ │ │ ├── media/
│ │ │ │ │ └── markdown.css
│ │ │ │ ├── releaseNotesEditor.ts
│ │ │ │ ├── update.contribution.ts
│ │ │ │ └── update.ts
│ │ │ └── common/
│ │ │ └── update.ts
│ │ ├── url/
│ │ │ └── common/
│ │ │ ├── externalUriResolver.ts
│ │ │ ├── trustedDomains.ts
│ │ │ ├── trustedDomainsFileSystemProvider.ts
│ │ │ ├── trustedDomainsValidator.ts
│ │ │ └── url.contribution.ts
│ │ ├── userDataSync/
│ │ │ ├── browser/
│ │ │ │ ├── userDataSync.contribution.ts
│ │ │ │ └── userDataSync.ts
│ │ │ └── electron-browser/
│ │ │ └── userDataSync.contribution.ts
│ │ ├── watermark/
│ │ │ └── browser/
│ │ │ ├── watermark.css
│ │ │ └── watermark.ts
│ │ ├── webview/
│ │ │ ├── browser/
│ │ │ │ ├── dynamicWebviewEditorOverlay.ts
│ │ │ │ ├── pre/
│ │ │ │ │ ├── fake.html
│ │ │ │ │ ├── host.js
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── main.js
│ │ │ │ │ └── service-worker.js
│ │ │ │ ├── webview.contribution.ts
│ │ │ │ ├── webview.ts
│ │ │ │ ├── webviewCommands.ts
│ │ │ │ ├── webviewEditor.ts
│ │ │ │ ├── webviewEditorInput.ts
│ │ │ │ ├── webviewEditorInputFactory.ts
│ │ │ │ ├── webviewElement.ts
│ │ │ │ ├── webviewFindWidget.ts
│ │ │ │ ├── webviewService.ts
│ │ │ │ └── webviewWorkbenchService.ts
│ │ │ ├── common/
│ │ │ │ ├── mimeTypes.ts
│ │ │ │ ├── portMapping.ts
│ │ │ │ ├── resourceLoader.ts
│ │ │ │ └── themeing.ts
│ │ │ └── electron-browser/
│ │ │ ├── pre/
│ │ │ │ └── electron-index.js
│ │ │ ├── webview.contribution.ts
│ │ │ ├── webviewCommands.ts
│ │ │ ├── webviewElement.ts
│ │ │ ├── webviewProtocols.ts
│ │ │ └── webviewService.ts
│ │ └── welcome/
│ │ ├── overlay/
│ │ │ └── browser/
│ │ │ ├── welcomeOverlay.css
│ │ │ └── welcomeOverlay.ts
│ │ ├── page/
│ │ │ └── browser/
│ │ │ ├── vs_code_welcome_page.ts
│ │ │ ├── welcomePage.contribution.ts
│ │ │ ├── welcomePage.css
│ │ │ └── welcomePage.ts
│ │ ├── telemetryOptOut/
│ │ │ ├── browser/
│ │ │ │ ├── telemetryOptOut.contribution.ts
│ │ │ │ └── telemetryOptOut.ts
│ │ │ └── electron-browser/
│ │ │ ├── telemetryOptOut.contribution.ts
│ │ │ └── telemetryOptOut.ts
│ │ └── walkThrough/
│ │ ├── browser/
│ │ │ ├── editor/
│ │ │ │ ├── editorWalkThrough.ts
│ │ │ │ └── vs_code_editor_walkthrough.ts
│ │ │ ├── walkThrough.contribution.ts
│ │ │ ├── walkThroughActions.ts
│ │ │ ├── walkThroughInput.ts
│ │ │ ├── walkThroughPart.css
│ │ │ └── walkThroughPart.ts
│ │ └── common/
│ │ ├── walkThroughContentProvider.ts
│ │ └── walkThroughUtils.ts
│ ├── electron-browser/
│ │ ├── actions/
│ │ │ ├── developerActions.ts
│ │ │ ├── windowActions.ts
│ │ │ └── workspaceActions.ts
│ │ ├── desktop.contribution.ts
│ │ ├── desktop.main.ts
│ │ └── window.ts
│ ├── services/
│ │ ├── accessibility/
│ │ │ └── node/
│ │ │ └── accessibilityService.ts
│ │ ├── activity/
│ │ │ ├── browser/
│ │ │ │ └── activityService.ts
│ │ │ └── common/
│ │ │ └── activity.ts
│ │ ├── activityBar/
│ │ │ └── browser/
│ │ │ └── activityBarService.ts
│ │ ├── authToken/
│ │ │ └── electron-browser/
│ │ │ └── authTokenService.ts
│ │ ├── backup/
│ │ │ ├── common/
│ │ │ │ ├── backup.ts
│ │ │ │ └── backupFileService.ts
│ │ │ ├── node/
│ │ │ │ └── backupFileService.ts
│ │ │ └── test/
│ │ │ └── node/
│ │ │ └── backupFileService.test.ts
│ │ ├── bulkEdit/
│ │ │ └── browser/
│ │ │ └── bulkEditService.ts
│ │ ├── clipboard/
│ │ │ ├── browser/
│ │ │ │ └── clipboardService.ts
│ │ │ └── electron-browser/
│ │ │ └── clipboardService.ts
│ │ ├── commands/
│ │ │ ├── common/
│ │ │ │ └── commandService.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ └── commandService.test.ts
│ │ ├── configuration/
│ │ │ ├── browser/
│ │ │ │ ├── configuration.ts
│ │ │ │ ├── configurationCache.ts
│ │ │ │ └── configurationService.ts
│ │ │ ├── common/
│ │ │ │ ├── configuration.ts
│ │ │ │ ├── configurationEditingService.ts
│ │ │ │ ├── configurationModels.ts
│ │ │ │ ├── jsonEditing.ts
│ │ │ │ └── jsonEditingService.ts
│ │ │ ├── node/
│ │ │ │ └── configurationCache.ts
│ │ │ └── test/
│ │ │ ├── common/
│ │ │ │ └── configurationModels.test.ts
│ │ │ └── electron-browser/
│ │ │ ├── configurationEditingService.test.ts
│ │ │ └── configurationService.test.ts
│ │ ├── configurationResolver/
│ │ │ ├── browser/
│ │ │ │ └── configurationResolverService.ts
│ │ │ ├── common/
│ │ │ │ ├── configurationResolver.ts
│ │ │ │ ├── configurationResolverSchema.ts
│ │ │ │ ├── configurationResolverUtils.ts
│ │ │ │ └── variableResolver.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── configurationResolverService.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ └── configurationResolverService.test.ts
│ │ ├── contextmenu/
│ │ │ └── electron-browser/
│ │ │ └── contextmenuService.ts
│ │ ├── credentials/
│ │ │ ├── browser/
│ │ │ │ └── credentialsService.ts
│ │ │ ├── common/
│ │ │ │ └── credentials.ts
│ │ │ └── node/
│ │ │ └── credentialsService.ts
│ │ ├── decorations/
│ │ │ ├── browser/
│ │ │ │ ├── decorations.ts
│ │ │ │ └── decorationsService.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ └── decorationsService.test.ts
│ │ ├── dialogs/
│ │ │ ├── browser/
│ │ │ │ ├── abstractFileDialogService.ts
│ │ │ │ ├── dialogService.ts
│ │ │ │ ├── fileDialogService.ts
│ │ │ │ └── simpleFileDialog.ts
│ │ │ └── electron-browser/
│ │ │ ├── dialogService.ts
│ │ │ └── fileDialogService.ts
│ │ ├── editor/
│ │ │ ├── browser/
│ │ │ │ ├── codeEditorService.ts
│ │ │ │ └── editorService.ts
│ │ │ ├── common/
│ │ │ │ ├── editorGroupsService.ts
│ │ │ │ └── editorService.ts
│ │ │ └── test/
│ │ │ └── browser/
│ │ │ ├── editorGroupsService.test.ts
│ │ │ └── editorService.test.ts
│ │ ├── electron/
│ │ │ └── electron-browser/
│ │ │ ├── electronEnvironmentService.ts
│ │ │ └── electronService.ts
│ │ ├── environment/
│ │ │ ├── browser/
│ │ │ │ └── environmentService.ts
│ │ │ ├── common/
│ │ │ │ └── environmentService.ts
│ │ │ └── node/
│ │ │ └── environmentService.ts
│ │ ├── extensionManagement/
│ │ │ ├── common/
│ │ │ │ ├── extensionEnablementService.ts
│ │ │ │ ├── extensionManagement.ts
│ │ │ │ ├── extensionManagementServerService.ts
│ │ │ │ └── extensionManagementService.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── extensionManagementServerService.ts
│ │ │ ├── node/
│ │ │ │ └── extensionManagementService.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ └── extensionEnablementService.test.ts
│ │ ├── extensions/
│ │ │ ├── browser/
│ │ │ │ ├── extensionService.ts
│ │ │ │ ├── extensionUrlHandler.ts
│ │ │ │ ├── webWorkerExtensionHostStarter.ts
│ │ │ │ └── webWorkerFileSystemProvider.ts
│ │ │ ├── common/
│ │ │ │ ├── abstractExtensionService.ts
│ │ │ │ ├── extensionDescriptionRegistry.ts
│ │ │ │ ├── extensionDevOptions.ts
│ │ │ │ ├── extensionHostMain.ts
│ │ │ │ ├── extensionHostProcessManager.ts
│ │ │ │ ├── extensionHostProtocol.ts
│ │ │ │ ├── extensionPoints.ts
│ │ │ │ ├── extensions.ts
│ │ │ │ ├── extensionsRegistry.ts
│ │ │ │ ├── extensionsUtil.ts
│ │ │ │ ├── lazyPromise.ts
│ │ │ │ ├── proxyIdentifier.ts
│ │ │ │ ├── remoteConsoleUtil.ts
│ │ │ │ ├── remoteExtensionHostClient.ts
│ │ │ │ ├── rpcProtocol.ts
│ │ │ │ └── staticExtensions.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── cachedExtensionScanner.ts
│ │ │ │ ├── extensionHost.ts
│ │ │ │ ├── extensionHostProfiler.ts
│ │ │ │ ├── extensionService.ts
│ │ │ │ └── remoteExtensionManagementIpc.ts
│ │ │ ├── node/
│ │ │ │ ├── extensionHostProcess.ts
│ │ │ │ ├── extensionHostProcessSetup.ts
│ │ │ │ ├── extensionPoints.ts
│ │ │ │ └── proxyResolver.ts
│ │ │ ├── test/
│ │ │ │ └── node/
│ │ │ │ └── rpcProtocol.test.ts
│ │ │ └── worker/
│ │ │ ├── extHost.services.ts
│ │ │ ├── extensionHostWorker.ts
│ │ │ └── extensionHostWorkerMain.ts
│ │ ├── history/
│ │ │ ├── browser/
│ │ │ │ └── history.ts
│ │ │ └── common/
│ │ │ └── history.ts
│ │ ├── host/
│ │ │ ├── browser/
│ │ │ │ ├── browserHostService.ts
│ │ │ │ └── host.ts
│ │ │ └── electron-browser/
│ │ │ └── desktopHostService.ts
│ │ ├── integrity/
│ │ │ ├── browser/
│ │ │ │ └── integrityService.ts
│ │ │ ├── common/
│ │ │ │ └── integrity.ts
│ │ │ └── node/
│ │ │ └── integrityService.ts
│ │ ├── issue/
│ │ │ └── electron-browser/
│ │ │ └── issueService.ts
│ │ ├── keybinding/
│ │ │ ├── browser/
│ │ │ │ ├── keybindingService.ts
│ │ │ │ ├── keyboardLayouts/
│ │ │ │ │ ├── _.contribution.ts
│ │ │ │ │ ├── cz.win.ts
│ │ │ │ │ ├── de-swiss.win.ts
│ │ │ │ │ ├── de.darwin.ts
│ │ │ │ │ ├── de.linux.ts
│ │ │ │ │ ├── de.win.ts
│ │ │ │ │ ├── dk.win.ts
│ │ │ │ │ ├── dvorak.darwin.ts
│ │ │ │ │ ├── en-belgian.win.ts
│ │ │ │ │ ├── en-ext.darwin.ts
│ │ │ │ │ ├── en-in.win.ts
│ │ │ │ │ ├── en-intl.darwin.ts
│ │ │ │ │ ├── en-intl.win.ts
│ │ │ │ │ ├── en-uk.darwin.ts
│ │ │ │ │ ├── en-uk.win.ts
│ │ │ │ │ ├── en.darwin.ts
│ │ │ │ │ ├── en.linux.ts
│ │ │ │ │ ├── en.win.ts
│ │ │ │ │ ├── es-latin.win.ts
│ │ │ │ │ ├── es.darwin.ts
│ │ │ │ │ ├── es.linux.ts
│ │ │ │ │ ├── es.win.ts
│ │ │ │ │ ├── fr.darwin.ts
│ │ │ │ │ ├── fr.linux.ts
│ │ │ │ │ ├── fr.win.ts
│ │ │ │ │ ├── hu.win.ts
│ │ │ │ │ ├── it.darwin.ts
│ │ │ │ │ ├── it.win.ts
│ │ │ │ │ ├── jp-roman.darwin.ts
│ │ │ │ │ ├── jp.darwin.ts
│ │ │ │ │ ├── ko.darwin.ts
│ │ │ │ │ ├── layout.contribution.darwin.ts
│ │ │ │ │ ├── layout.contribution.linux.ts
│ │ │ │ │ ├── layout.contribution.win.ts
│ │ │ │ │ ├── no.win.ts
│ │ │ │ │ ├── pl.darwin.ts
│ │ │ │ │ ├── pl.win.ts
│ │ │ │ │ ├── pt-br.win.ts
│ │ │ │ │ ├── pt.darwin.ts
│ │ │ │ │ ├── pt.win.ts
│ │ │ │ │ ├── ru.darwin.ts
│ │ │ │ │ ├── ru.linux.ts
│ │ │ │ │ ├── ru.win.ts
│ │ │ │ │ ├── sv.darwin.ts
│ │ │ │ │ ├── sv.win.ts
│ │ │ │ │ ├── thai.win.ts
│ │ │ │ │ ├── tr.win.ts
│ │ │ │ │ └── zh-hans.darwin.ts
│ │ │ │ ├── keymapService.ts
│ │ │ │ └── navigatorKeyboard.ts
│ │ │ ├── common/
│ │ │ │ ├── dispatchConfig.ts
│ │ │ │ ├── keybindingEditing.ts
│ │ │ │ ├── keybindingIO.ts
│ │ │ │ ├── keyboardMapper.ts
│ │ │ │ ├── keymapInfo.ts
│ │ │ │ ├── macLinuxFallbackKeyboardMapper.ts
│ │ │ │ ├── macLinuxKeyboardMapper.ts
│ │ │ │ └── windowsKeyboardMapper.ts
│ │ │ ├── electron-browser/
│ │ │ │ ├── keybinding.contribution.ts
│ │ │ │ └── nativeKeymapService.ts
│ │ │ └── test/
│ │ │ ├── browserKeyboardMapper.test.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── keybindingEditing.test.ts
│ │ │ ├── keybindingIO.test.ts
│ │ │ ├── keyboardMapperTestUtils.ts
│ │ │ ├── linux_de_ch.js
│ │ │ ├── linux_de_ch.txt
│ │ │ ├── linux_en_uk.js
│ │ │ ├── linux_en_uk.txt
│ │ │ ├── linux_en_us.js
│ │ │ ├── linux_en_us.txt
│ │ │ ├── linux_ru.js
│ │ │ ├── linux_ru.txt
│ │ │ ├── macLinuxFallbackKeyboardMapper.test.ts
│ │ │ ├── macLinuxKeyboardMapper.test.ts
│ │ │ ├── mac_de_ch.js
│ │ │ ├── mac_de_ch.txt
│ │ │ ├── mac_en_us.js
│ │ │ ├── mac_en_us.txt
│ │ │ ├── mac_zh_hant.js
│ │ │ ├── mac_zh_hant.txt
│ │ │ ├── win_de_ch.js
│ │ │ ├── win_de_ch.txt
│ │ │ ├── win_en_us.js
│ │ │ ├── win_en_us.txt
│ │ │ ├── win_por_ptb.js
│ │ │ ├── win_por_ptb.txt
│ │ │ ├── win_ru.js
│ │ │ ├── win_ru.txt
│ │ │ └── windowsKeyboardMapper.test.ts
│ │ ├── label/
│ │ │ ├── common/
│ │ │ │ └── labelService.ts
│ │ │ └── test/
│ │ │ └── label.test.ts
│ │ ├── layout/
│ │ │ └── browser/
│ │ │ └── layoutService.ts
│ │ ├── lifecycle/
│ │ │ ├── browser/
│ │ │ │ └── lifecycleService.ts
│ │ │ └── electron-browser/
│ │ │ └── lifecycleService.ts
│ │ ├── localizations/
│ │ │ └── electron-browser/
│ │ │ └── localizationsService.ts
│ │ ├── log/
│ │ │ ├── browser/
│ │ │ │ └── indexedDBLogProvider.ts
│ │ │ └── common/
│ │ │ ├── inMemoryLogProvider.ts
│ │ │ └── keyValueLogProvider.ts
│ │ ├── menubar/
│ │ │ └── electron-browser/
│ │ │ └── menubarService.ts
│ │ ├── mode/
│ │ │ └── common/
│ │ │ └── workbenchModeService.ts
│ │ ├── notification/
│ │ │ └── common/
│ │ │ └── notificationService.ts
│ │ ├── output/
│ │ │ ├── common/
│ │ │ │ ├── outputChannelModel.ts
│ │ │ │ └── outputChannelModelService.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── outputChannelModelService.ts
│ │ │ └── node/
│ │ │ └── outputAppender.ts
│ │ ├── panel/
│ │ │ └── common/
│ │ │ └── panelService.ts
│ │ ├── preferences/
│ │ │ ├── browser/
│ │ │ │ └── preferencesService.ts
│ │ │ ├── common/
│ │ │ │ ├── keybindingsEditorModel.ts
│ │ │ │ ├── preferences.ts
│ │ │ │ ├── preferencesEditorInput.ts
│ │ │ │ └── preferencesModels.ts
│ │ │ └── test/
│ │ │ └── common/
│ │ │ ├── keybindingsEditorModel.test.ts
│ │ │ └── preferencesModel.test.ts
│ │ ├── progress/
│ │ │ ├── browser/
│ │ │ │ ├── editorProgressService.ts
│ │ │ │ ├── media/
│ │ │ │ │ └── progressService.css
│ │ │ │ ├── progressIndicator.ts
│ │ │ │ └── progressService.ts
│ │ │ └── test/
│ │ │ └── progressIndicator.test.ts
│ │ ├── remote/
│ │ │ ├── browser/
│ │ │ │ └── remoteAgentServiceImpl.ts
│ │ │ ├── common/
│ │ │ │ ├── abstractRemoteAgentService.ts
│ │ │ │ ├── remoteAgentEnvironmentChannel.ts
│ │ │ │ └── remoteAgentService.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── remoteAgentServiceImpl.ts
│ │ │ └── node/
│ │ │ └── tunnelService.ts
│ │ ├── request/
│ │ │ ├── browser/
│ │ │ │ └── requestService.ts
│ │ │ └── electron-browser/
│ │ │ └── requestService.ts
│ │ ├── search/
│ │ │ ├── common/
│ │ │ │ ├── replace.ts
│ │ │ │ ├── search.ts
│ │ │ │ ├── searchExtTypes.ts
│ │ │ │ ├── searchHelpers.ts
│ │ │ │ └── searchService.ts
│ │ │ ├── node/
│ │ │ │ ├── fileSearch.ts
│ │ │ │ ├── fileSearchManager.ts
│ │ │ │ ├── rawSearchService.ts
│ │ │ │ ├── ripgrepFileSearch.ts
│ │ │ │ ├── ripgrepSearchProvider.ts
│ │ │ │ ├── ripgrepSearchUtils.ts
│ │ │ │ ├── ripgrepTextSearchEngine.ts
│ │ │ │ ├── searchApp.ts
│ │ │ │ ├── searchIpc.ts
│ │ │ │ ├── searchService.ts
│ │ │ │ ├── textSearchAdapter.ts
│ │ │ │ └── textSearchManager.ts
│ │ │ └── test/
│ │ │ ├── common/
│ │ │ │ ├── replace.test.ts
│ │ │ │ ├── search.test.ts
│ │ │ │ └── searchHelpers.test.ts
│ │ │ └── node/
│ │ │ ├── fixtures/
│ │ │ │ ├── binary.wuff
│ │ │ │ ├── examples/
│ │ │ │ │ ├── NullPoinderException.js
│ │ │ │ │ ├── company.js
│ │ │ │ │ ├── employee.js
│ │ │ │ │ ├── small.js
│ │ │ │ │ └── subfolder/
│ │ │ │ │ ├── anotherfolder/
│ │ │ │ │ │ └── anotherfile.txt
│ │ │ │ │ └── subfile.txt
│ │ │ │ ├── index.html
│ │ │ │ ├── more/
│ │ │ │ │ └── file.txt
│ │ │ │ ├── site.css
│ │ │ │ ├── site.less
│ │ │ │ ├── some_utf16be.css
│ │ │ │ ├── some_utf16le.css
│ │ │ │ └── üm laut汉语/
│ │ │ │ └── 汉语.txt
│ │ │ ├── fixtures2/
│ │ │ │ └── 36438/
│ │ │ │ ├── modules/
│ │ │ │ │ └── do-not-find.txt
│ │ │ │ └── more/
│ │ │ │ └── modules/
│ │ │ │ └── find.txt
│ │ │ ├── rawSearchService.test.ts
│ │ │ ├── ripgrepFileSearch.test.ts
│ │ │ ├── ripgrepTextSearchEngine.test.ts
│ │ │ ├── search.test.ts
│ │ │ ├── textSearch.integrationTest.ts
│ │ │ └── textSearchManager.test.ts
│ │ ├── sharedProcess/
│ │ │ └── electron-browser/
│ │ │ └── sharedProcessService.ts
│ │ ├── statusbar/
│ │ │ └── common/
│ │ │ └── statusbar.ts
│ │ ├── telemetry/
│ │ │ ├── browser/
│ │ │ │ └── telemetryService.ts
│ │ │ └── electron-browser/
│ │ │ └── telemetryService.ts
│ │ ├── textMate/
│ │ │ ├── browser/
│ │ │ │ ├── abstractTextMateService.ts
│ │ │ │ └── textMateService.ts
│ │ │ ├── common/
│ │ │ │ ├── TMGrammarFactory.ts
│ │ │ │ ├── TMGrammars.ts
│ │ │ │ ├── TMHelper.ts
│ │ │ │ ├── TMScopeRegistry.ts
│ │ │ │ ├── cgmanifest.json
│ │ │ │ └── textMateService.ts
│ │ │ └── electron-browser/
│ │ │ ├── textMateService.ts
│ │ │ └── textMateWorker.ts
│ │ ├── textfile/
│ │ │ ├── browser/
│ │ │ │ ├── browserTextFileService.ts
│ │ │ │ └── textFileService.ts
│ │ │ ├── common/
│ │ │ │ ├── textFileEditorModel.ts
│ │ │ │ ├── textFileEditorModelManager.ts
│ │ │ │ ├── textResourcePropertiesService.ts
│ │ │ │ └── textfiles.ts
│ │ │ ├── electron-browser/
│ │ │ │ └── nativeTextFileService.ts
│ │ │ └── test/
│ │ │ ├── fixtures/
│ │ │ │ ├── binary.txt
│ │ │ │ ├── index.html
│ │ │ │ ├── lorem.txt
│ │ │ │ ├── lorem_big5.txt
│ │ │ │ ├── lorem_cp1252.txt
│ │ │ │ ├── lorem_cp866.txt
│ │ │ │ ├── lorem_gbk.txt
│ │ │ │ ├── lorem_shiftjis.txt
│ │ │ │ ├── lorem_utf16be.txt
│ │ │ │ ├── lorem_utf16le.txt
│ │ │ │ ├── lorem_utf8bom.txt
│ │ │ │ ├── small.txt
│ │ │ │ ├── small_umlaut.txt
│ │ │ │ ├── some.utf16le
│ │ │ │ ├── some_big5.txt
│ │ │ │ ├── some_cp1252.txt
│ │ │ │ ├── some_cyrillic.txt
│ │ │ │ ├── some_gbk.txt
│ │ │ │ ├── some_shiftjs.txt
│ │ │ │ ├── some_small_cp1252.txt
│ │ │ │ ├── some_utf16le.css
│ │ │ │ ├── some_utf8_bom.txt
│ │ │ │ ├── utf16_be_nobom.txt
│ │ │ │ └── utf16_le_nobom.txt
│ │ │ ├── textFileEditorModel.test.ts
│ │ │ ├── textFileEditorModelManager.test.ts
│ │ │ ├── textFileService.io.test.ts
│ │ │ └── textFileService.test.ts
│ │ ├── textmodelResolver/
│ │ │ ├── common/
│ │ │ │ └── textModelResolverService.ts
│ │ │ └── test/
│ │ │ └── textModelResolverService.test.ts
│ │ ├── themes/
│ │ │ ├── browser/
│ │ │ │ ├── fileIconThemeData.ts
│ │ │ │ ├── fileIconThemeStore.ts
│ │ │ │ └── workbenchThemeService.ts
│ │ │ └── common/
│ │ │ ├── colorExtensionPoint.ts
│ │ │ ├── colorThemeData.ts
│ │ │ ├── colorThemeSchema.ts
│ │ │ ├── colorThemeStore.ts
│ │ │ ├── fileIconThemeSchema.ts
│ │ │ ├── plistParser.ts
│ │ │ ├── themeCompatibility.ts
│ │ │ └── workbenchThemeService.ts
│ │ ├── timer/
│ │ │ └── electron-browser/
│ │ │ └── timerService.ts
│ │ ├── title/
│ │ │ └── common/
│ │ │ └── titleService.ts
│ │ ├── untitled/
│ │ │ └── common/
│ │ │ └── untitledEditorService.ts
│ │ ├── update/
│ │ │ ├── browser/
│ │ │ │ └── updateService.ts
│ │ │ └── electron-browser/
│ │ │ └── updateService.ts
│ │ ├── url/
│ │ │ ├── browser/
│ │ │ │ └── urlService.ts
│ │ │ └── electron-browser/
│ │ │ └── urlService.ts
│ │ ├── userData/
│ │ │ ├── common/
│ │ │ │ ├── fileUserDataProvider.ts
│ │ │ │ └── inMemoryUserDataProvider.ts
│ │ │ └── test/
│ │ │ └── electron-browser/
│ │ │ └── fileUserDataProvider.test.ts
│ │ ├── userDataSync/
│ │ │ ├── common/
│ │ │ │ └── settingsMergeService.ts
│ │ │ └── electron-browser/
│ │ │ └── userDataSyncService.ts
│ │ ├── viewlet/
│ │ │ └── browser/
│ │ │ └── viewlet.ts
│ │ └── workspaces/
│ │ ├── browser/
│ │ │ ├── abstractWorkspaceEditingService.ts
│ │ │ ├── workspaceEditingService.ts
│ │ │ └── workspacesService.ts
│ │ ├── common/
│ │ │ └── workspaceEditing.ts
│ │ └── electron-browser/
│ │ ├── workspaceEditingService.ts
│ │ └── workspacesService.ts
│ ├── test/
│ │ ├── browser/
│ │ │ ├── actionRegistry.test.ts
│ │ │ ├── part.test.ts
│ │ │ ├── parts/
│ │ │ │ ├── editor/
│ │ │ │ │ ├── baseEditor.test.ts
│ │ │ │ │ ├── breadcrumbModel.test.ts
│ │ │ │ │ └── rangeDecorations.test.ts
│ │ │ │ └── views/
│ │ │ │ └── views.test.ts
│ │ │ ├── quickopen.test.ts
│ │ │ └── viewlet.test.ts
│ │ ├── common/
│ │ │ ├── editor/
│ │ │ │ ├── dataUriEditorInput.test.ts
│ │ │ │ ├── editor.test.ts
│ │ │ │ ├── editorDiffModel.test.ts
│ │ │ │ ├── editorGroups.test.ts
│ │ │ │ ├── editorInput.test.ts
│ │ │ │ ├── editorModel.test.ts
│ │ │ │ ├── editorOptions.test.ts
│ │ │ │ ├── resourceEditorInput.test.ts
│ │ │ │ └── untitledEditor.test.ts
│ │ │ ├── memento.test.ts
│ │ │ └── notifications.test.ts
│ │ ├── contrib/
│ │ │ └── linkProtection.test.ts
│ │ ├── electron-browser/
│ │ │ ├── api/
│ │ │ │ ├── extHost.api.impl.test.ts
│ │ │ │ ├── extHostApiCommands.test.ts
│ │ │ │ ├── extHostCommands.test.ts
│ │ │ │ ├── extHostConfiguration.test.ts
│ │ │ │ ├── extHostDiagnostics.test.ts
│ │ │ │ ├── extHostDocumentData.test.ts
│ │ │ │ ├── extHostDocumentSaveParticipant.test.ts
│ │ │ │ ├── extHostDocumentsAndEditors.test.ts
│ │ │ │ ├── extHostFileSystemEventService.test.ts
│ │ │ │ ├── extHostLanguageFeatures.test.ts
│ │ │ │ ├── extHostMessagerService.test.ts
│ │ │ │ ├── extHostSearch.test.ts
│ │ │ │ ├── extHostTextEditor.test.ts
│ │ │ │ ├── extHostTextEditors.test.ts
│ │ │ │ ├── extHostTreeViews.test.ts
│ │ │ │ ├── extHostTypeConverter.test.ts
│ │ │ │ ├── extHostTypes.test.ts
│ │ │ │ ├── extHostWebview.test.ts
│ │ │ │ ├── extHostWorkspace.test.ts
│ │ │ │ ├── mainThreadCommands.test.ts
│ │ │ │ ├── mainThreadConfiguration.test.ts
│ │ │ │ ├── mainThreadDiagnostics.test.ts
│ │ │ │ ├── mainThreadDocumentContentProviders.test.ts
│ │ │ │ ├── mainThreadDocuments.test.ts
│ │ │ │ ├── mainThreadDocumentsAndEditors.test.ts
│ │ │ │ ├── mainThreadEditors.test.ts
│ │ │ │ ├── mainThreadSaveParticipant.test.ts
│ │ │ │ ├── mainThreadWorkspace.test.ts
│ │ │ │ ├── mock.ts
│ │ │ │ └── testRPCProtocol.ts
│ │ │ ├── colorRegistry.releaseTest.ts
│ │ │ ├── quickopen.perf.integrationTest.ts
│ │ │ └── textsearch.perf.integrationTest.ts
│ │ └── workbenchTestServices.ts
│ ├── workbench.common.main.ts
│ ├── workbench.desktop.main.css
│ ├── workbench.desktop.main.nls.js
│ ├── workbench.desktop.main.ts
│ ├── workbench.web.api.css
│ ├── workbench.web.api.nls.js
│ ├── workbench.web.api.ts
│ └── workbench.web.main.ts
├── test/
│ ├── README.md
│ ├── all.js
│ ├── assert.js
│ ├── automation/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── activityBar.ts
│ │ │ ├── application.ts
│ │ │ ├── code.ts
│ │ │ ├── debug.ts
│ │ │ ├── driver.js
│ │ │ ├── editor.ts
│ │ │ ├── editors.ts
│ │ │ ├── explorer.ts
│ │ │ ├── extensions.ts
│ │ │ ├── index.ts
│ │ │ ├── keybindings.ts
│ │ │ ├── logger.ts
│ │ │ ├── peek.ts
│ │ │ ├── problems.ts
│ │ │ ├── puppeteerDriver.ts
│ │ │ ├── quickinput.ts
│ │ │ ├── quickopen.ts
│ │ │ ├── scm.ts
│ │ │ ├── search.ts
│ │ │ ├── settings.ts
│ │ │ ├── statusbar.ts
│ │ │ ├── terminal.ts
│ │ │ ├── viewlet.ts
│ │ │ └── workbench.ts
│ │ ├── tools/
│ │ │ ├── copy-driver-definition.js
│ │ │ └── copy-package-version.js
│ │ └── tsconfig.json
│ ├── browser.js
│ ├── cgmanifest.json
│ ├── coverage.js
│ ├── css.mock.js
│ ├── electron/
│ │ ├── index.js
│ │ ├── renderer.html
│ │ └── renderer.js
│ ├── index.html
│ ├── mocha.opts
│ ├── smoke/
│ │ ├── .gitignore
│ │ ├── Audit.md
│ │ ├── README.md
│ │ ├── package.json
│ │ ├── src/
│ │ │ ├── areas/
│ │ │ │ ├── css/
│ │ │ │ │ └── css.test.ts
│ │ │ │ ├── debug/
│ │ │ │ │ └── debug.test.ts
│ │ │ │ ├── editor/
│ │ │ │ │ └── editor.test.ts
│ │ │ │ ├── explorer/
│ │ │ │ │ └── explorer.test.ts
│ │ │ │ ├── extensions/
│ │ │ │ │ └── extensions.test.ts
│ │ │ │ ├── git/
│ │ │ │ │ └── git.test.ts
│ │ │ │ ├── multiroot/
│ │ │ │ │ └── multiroot.test.ts
│ │ │ │ ├── preferences/
│ │ │ │ │ └── preferences.test.ts
│ │ │ │ ├── search/
│ │ │ │ │ └── search.test.ts
│ │ │ │ ├── statusbar/
│ │ │ │ │ └── statusbar.test.ts
│ │ │ │ ├── terminal/
│ │ │ │ │ └── terminal.test.ts
│ │ │ │ └── workbench/
│ │ │ │ ├── data-loss.test.ts
│ │ │ │ ├── data-migration.test.ts
│ │ │ │ ├── launch.test.ts
│ │ │ │ └── localization.test.ts
│ │ │ ├── main.ts
│ │ │ └── utils.ts
│ │ ├── test/
│ │ │ └── index.js
│ │ └── tsconfig.json
│ ├── splitview/
│ │ ├── package.json
│ │ ├── public/
│ │ │ └── index.html
│ │ └── server.js
│ └── tree/
│ ├── package.json
│ ├── public/
│ │ ├── compressed.json
│ │ └── index.html
│ ├── server.js
│ └── tree.js
├── tsfmt.json
└── tslint.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
# EditorConfig is awesome: https://EditorConfig.org
# top-most EditorConfig file
root = true
# Tab indentation
[*]
indent_style = tab
trim_trailing_whitespace = true
# The indent size used in the `package.json` file cannot be changed
# https://github.com/npm/npm/pull/3180#issuecomment-16336516
[{*.yml,*.yaml,package.json}]
indent_style = space
indent_size = 2
================================================
FILE: .eslintrc.json
================================================
{
"root": true,
"env": {
"node": true,
"es6": true
},
"rules": {
"no-console": 0,
"no-cond-assign": 0,
"no-unused-vars": 1,
"no-extra-semi": "warn",
"semi": "warn"
},
"extends": "eslint:recommended",
"parserOptions": {
"ecmaFeatures": {
"experimentalObjectRestSpread": true
}
}
}
================================================
FILE: .gitattributes
================================================
* text=auto
LICENSE.txt eol=crlf
ThirdPartyNotices.txt eol=crlf
*.bat eol=crlf
*.cmd eol=crlf
*.ps1 eol=lf
*.sh eol=lf
*.rtf -text
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report (问题反馈)
about: Create a report to help us improve (汇报你发现的BUG，帮助我们改善IDE)
---
- IDE Version: (see MenuBar -> Help -> About)
- Platform: Windows / Linux / Mac
### Steps to Reproduce:
1.
1.
### More info:
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request (功能请求)
about: Suggest an idea for this project (提议将来添加到IDE的新功能)
---
----
================================================
FILE: .github/ISSUE_TEMPLATE/question.md
================================================
---
name: Question (问题)
about: Ask question about IDE (在使用IDE的过程中出现的疑问)
---
### Your Question:
================================================
FILE: .github/ISSUE_TEMPLATE/question_cn.md
================================================
---
name:
about:
---
================================================
FILE: .github/calendar.yml
================================================
{
'2018-01-29 18:00, US/Pacific': 'endgame',
'2018-02-07 12:00, US/Pacific': 'release', # 1.20.0
'2018-02-12 12:00, US/Pacific': 'development',
'2018-02-14 16:00, Europe/Zurich': 'release', # 1.20.1
'2018-02-19 16:00, Europe/Zurich': 'development',
'2018-02-26 18:00, US/Pacific': 'endgame',
'2018-03-07 12:00, US/Pacific': 'release', # 1.21.0
'2018-03-12 12:00, US/Pacific': 'development',
'2018-03-15 12:00, US/Pacific': 'release', # 1.21.1
'2018-03-20 12:00, US/Pacific': 'development',
'2018-03-26 18:00, US/Pacific': 'endgame',
'2018-04-06 18:00, US/Pacific': 'release', # 1.22.1
'2018-04-11 18:00, US/Pacific': 'development',
'2018-04-12 12:00, US/Pacific': 'release', # 1.22.2
'2018-04-17 12:00, US/Pacific': 'development',
'2018-04-23 18:00, US/Pacific': 'endgame',
'2018-05-03 12:00, US/Pacific': 'release', # 1.23.0
'2018-05-08 12:00, US/Pacific': 'development',
'2018-05-10 12:00, US/Pacific': 'release', # 1.23.1
'2018-05-15 12:00, US/Pacific': 'development',
'2018-05-28 18:00, US/Pacific': 'endgame',
# 'release' not needed anymore, return to 'development' after releasing.
'2018-06-06 12:00, US/Pacific': 'development', # 1.24.0 released
'2018-06-25 18:00, US/Pacific': 'endgame',
'2018-07-05 12:00, US/Pacific': 'development', # 1.25.0 released
'2018-07-30 18:00, US/Pacific': 'endgame',
'2018-08-13 12:00, US/Pacific': 'development', # 1.26.0 released
'2018-08-27 18:00, US/Pacific': 'endgame',
'2018-09-05 12:00, US/Pacific': 'development', # 1.27.0 released
'2018-09-24 18:00, US/Pacific': 'endgame',
'2018-10-08 09:00, US/Pacific': 'development', # 1.28.0 released
'2018-10-29 18:00, US/Pacific': 'endgame',
'2018-11-12 11:00, US/Pacific': 'development', # 1.29.0 released
'2018-12-03 18:00, US/Pacific': 'endgame',
'2018-12-12 13:00, US/Pacific': 'development', # 1.30.0 released
}
================================================
FILE: .github/classifier.yml
================================================
{
perform: false,
alwaysRequireAssignee: false,
labelsRequiringAssignee: [],
autoAssignees: {
L10N: [],
VIM: [],
api: {
assignees: [ jrieken ],
assignLabel: false
},
cli: [],
color-palette: [],
config: [],
css-less-scss: [],
debug-console: [],
debug: {
assignees: [ isidorn ],
assignLabel: false
},
diff-editor: : {
assignees: [],
assignLabel: false
},
dropdown: [],
editor: : {
assignees: [],
assignLabel: false
},
editor-1000-limit: : {
assignees: [],
assignLabel: false
},
editor-autoclosing: : {
assignees: [],
assignLabel: false
},
editor-autoindent: : {
assignees: [],
assignLabel: false
},
editor-brackets: : {
assignees: [],
assignLabel: false
},
editor-clipboard: : {
assignees: [],
assignLabel: false
},
editor-code-actions: : {
assignees: [],
assignLabel: false
},
editor-code-lens: : {
assignees: [],
assignLabel: false
},
editor-color-picker: : {
assignees: [],
assignLabel: false
},
editor-colors: : {
assignees: [],
assignLabel: false
},
editor-columnselect: : {
assignees: [],
assignLabel: false
},
editor-commands: : {
assignees: [],
assignLabel: false
},
editor-contrib: : {
assignees: [],
assignLabel: false
},
editor-drag-and-drop: : {
assignees: [],
assignLabel: false
},
editor-find: : {
assignees: [],
assignLabel: false
},
editor-folding: : {
assignees: [],
assignLabel: false
},
editor-hover: : {
assignees: [],
assignLabel: false
},
editor-ime: : {
assignees: [],
assignLabel: false
},
editor-input: : {
assignees: [],
assignLabel: false
},
editor-ligatures: : {
assignees: [],
assignLabel: false
},
editor-links: : {
assignees: [],
assignLabel: false
},
editor-minimap: : {
assignees: [],
assignLabel: false
},
editor-multicursor: : {
assignees: [],
assignLabel: false
},
editor-parameter-hints: : {
assignees: [],
assignLabel: false
},
editor-rendering: : {
assignees: [],
assignLabel: false
},
editor-smooth: : {
assignees: [],
assignLabel: false
},
editor-symbols: : {
assignees: [],
assignLabel: false
},
editor-textbuffer: : {
assignees: [],
assignLabel: false
},
editor-wrapping: : {
assignees: [],
assignLabel: false
},
emmet: [ octref ],
error-list: [],
explorer-custom: [],
extension-host: [],
extensions: [],
file-decorations: [],
file-encoding: {
assignees: [],
assignLabel: false
},
file-explorer: {
assignees: [ isidorn ],
assignLabel: false
},
file-glob: [],
file-io: {
assignees: [],
assignLabel: false
},
file-watcher: {
assignees: [],
assignLabel: false
},
formatting: [],
git: [],
grammar: [],
hot-exit: [],
html: [],
install-update: [],
integrated-terminal: [],
integration-test: [],
intellisense-config: [],
issue-reporter: [ RMacfarlane ],
javascript: [ mjbvz ],
json: [],
keyboard-layout: : {
assignees: [],
assignLabel: false
},
keybindings: : {
assignees: [],
assignLabel: false
},
keybindings-editor: [],
lang-diagnostics: [],
languages basic: [],
list: [],
log: [],
markdown: [ mjbvz ],
marketplace: [],
menus: [],
merge-conflict: [ chrmarti ],
multi-root: {
assignees: [],
assignLabel: false
},
os-integration: [],
outline: [],
output: [],
perf-profile: [],
perf-bloat: [],
perf-startup: [],
php: [ roblourens ],
proxy: [],
quick-pick: [ chrmarti ],
release-notes: [],
remote: {
assignees: [ jrieken ],
assignLabel: false
},
rename: [],
run-as-admin: [],
samples: [],
scm: [],
search: [ roblourens ],
search-replace: [],
settings-editor: [],
shared-process: [],
smart-select: [],
smoke-test: [],
snippets: {
assignees: [ jrieken ],
assignLabel: false
},
suggest: [],
tasks: [ alexr00 ],
telemetry: [],
themes: [],
tokenization: [],
tree: [],
typescript: [ mjbvz ],
unit-test: [],
uri: [],
ux: [],
vscode-build: [],
webview: [],
workbench: {
assignees: [],
assignLabel: false
},
workbench-diagnostics: {
assignees: [],
assignLabel: false
},
workbench-dnd: {
assignees: [],
assignLabel: false
},
workbench-editors: {
assignees: [],
assignLabel: false
},
workbench-electron: {
assignees: [],
assignLabel: false
},
workbench-feedback: {
assignees: [],
assignLabel: false
},
workbench-grid: {
assignees: [],
assignLabel: false
},
workbench-history: {
assignees: [],
assignLabel: false
},
workbench-layout: {
assignees: [],
assignLabel: false
},
workbench-menu: {
assignees: [],
assignLabel: false
},
workbench-notifications: {
assignees: [],
assignLabel: false
},
workbench-state: {
assignees: [],
assignLabel: false
},
workbench-status: {
assignees: [],
assignLabel: false
},
workbench-tabs: {
assignees: [],
assignLabel: false
},
workbench-title: {
assignees: [],
assignLabel: false
},
workbench-touchbar: {
assignees: [],
assignLabel: false
},
workbench-views: {
assignees: [],
assignLabel: false
},
workbench-welcome: [ chrmarti ]
}
}
================================================
FILE: .github/commands.yml
================================================
{
perform: true,
commands: [
{
type: 'comment',
name: 'question',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'updateLabels',
addLabel: '*question'
},
{
type: 'label',
name: '*question',
allowTriggerByBot: true,
action: 'close',
comment: "Please ask your question on [StackOverflow](https://aka.ms/vscodestackoverflow). We have a great community over [there](https://aka.ms/vscodestackoverflow). They have already answered thousands of questions and are happy to answer yours as well. See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
},
{
type: 'label',
name: '*dev-question',
allowTriggerByBot: true,
action: 'close',
comment: "We have a great developer community [over on slack](https://aka.ms/vscode-dev-community) where extension authors help each other. This is a great place for you to ask questions and find support.\n\nHappy Coding!"
},
{
type: 'label',
name: '*extension-candidate',
allowTriggerByBot: true,
action: 'close',
comment: "We try to keep VS Code lean and we think the functionality you're asking for is great for a VS Code extension. Maybe you can already find one that suits you in the [VS Code Marketplace](https://aka.ms/vscodemarketplace). Just in case, in a few simple steps you can get started [writing your own extension](https://aka.ms/vscodewritingextensions). See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
},
{
type: 'label',
name: '*not-reproducible',
allowTriggerByBot: true,
action: 'close',
comment: "We closed this issue because we are unable to reproduce the problem with the steps you describe. Chances are we've already fixed your problem in a recent version of VS Code. If not, please ask us to reopen the issue and provide us with more detail. Our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines might help you with that.\n\nHappy Coding!"
},
{
type: 'label',
name: '*out-of-scope',
allowTriggerByBot: true,
action: 'close',
comment: "This issue is being closed to keep the number of issues in our inbox on a manageable level, we are closing issues that are not going to be addressed in the foreseeable future: We look at the number of votes the issue has received and the number of duplicate issues filed. More details [here](https://aka.ms/vscode-out-of-scope). If you disagree and feel that this issue is crucial: We are happy to listen and to reconsider.\n\nIf you wonder what we are up to, please see our [roadmap](https://aka.ms/vscoderoadmap) and [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nThanks for your understanding and happy coding!"
},
{
type: 'comment',
name: 'causedByExtension',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'updateLabels',
addLabel: '*caused-by-extension'
},
{
type: 'label',
name: '*caused-by-extension',
allowTriggerByBot: true,
action: 'close',
comment: "This issue is caused by an extension, please file it with the repository (or contact) the extension has linked in its overview in VS Code or the [marketplace](https://aka.ms/vscodemarketplace) for VS Code. See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
},
{
type: 'label',
name: '*as-designed',
allowTriggerByBot: true,
action: 'close',
comment: "The described behavior is how it is expected to work. If you disagree, please explain what is expected and what is not in more detail. See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
},
{
type: 'label',
name: '*english-please',
allowTriggerByBot: true,
action: 'close',
comment: "This issue is being closed because its description is not in English, that makes it hard for us to work on it. Please open a new issue with an English description. You might find [Bing Translator](https://www.bing.com/translator) useful."
},
{
type: 'comment',
name: 'duplicate',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'updateLabels',
addLabel: '*duplicate'
},
{
type: 'label',
name: '*duplicate',
allowTriggerByBot: true,
action: 'close',
comment: "Thanks for creating this issue! We figured it's covering the same as another one we already have. Thus, we closed this one as a duplicate. You can search for existing issues [here](https://aka.ms/vscodeissuesearch). See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
},
{
type: 'comment',
name: 'confirm',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'updateLabels',
addLabel: 'confirmed',
removeLabel: 'confirmation-pending'
},
{
type: 'comment',
name: 'confirmationPending',
allowUsers: ['cleidigh', 'usernamehw'],
action: 'updateLabels',
addLabel: 'confirmation-pending',
removeLabel: 'confirmed'
},
{
type: 'comment',
name: 'findDuplicates',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'comment',
comment: "Potential duplicates:\n${potentialDuplicates}"
},
{
type: 'comment',
name: 'needsMoreInfo',
allowUsers: ['cleidigh', 'usernamehw', 'gjsjohnmurray', 'IllusionMH'],
action: 'updateLabels',
addLabel: 'needs more info',
comment: "Thanks for creating this issue! We figured it's missing some basic information or in some other way doesn't follow our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines. Please take the time to review these and update the issue.\n\nHappy Coding!"
},
{
type: 'comment',
name: 'a11ymas',
allowUsers: ['AccessibilityTestingTeam-TCS', 'dixitsonali95', 'Mohini78', 'ChitrarupaSharma', 'mspatil110', 'umasarath52', 'v-umnaik'],
action: 'updateLabels',
addLabel: 'a11ymas'
},
]
}
================================================
FILE: .github/copycat.yml
================================================
{
perform: true,
target_owner: 'chrmarti',
target_repo: 'testissues'
}
================================================
FILE: .github/endgame/insiders.yml
================================================
{
insidersLabel: 'insiders',
insidersColor: '006b75',
action: 'add',
perform: true
}
================================================
FILE: .github/insiders.yml
================================================
{
insidersLabel: 'insiders',
insidersColor: '006b75',
action: 'remove',
perform: true
}
================================================
FILE: .github/locker.yml
================================================
{
daysAfterClose: 45,
daysSinceLastUpdate: 3,
ignoredLabels: ['*out-of-scope'],
perform: true
}
================================================
FILE: .github/needs_more_info.yml
================================================
{
daysUntilClose: 7,
needsMoreInfoLabel: 'needs more info',
perform: true,
closeComment: "This issue has been closed automatically because it needs more information and has not had recent activity. See also our [issue reporting](https://aka.ms/vscodeissuereporting) guidelines.\n\nHappy Coding!"
}
================================================
FILE: .github/new_release.yml
================================================
{
newReleaseLabel: 'new release',
newReleaseColor: '006b75',
daysAfterRelease: 5,
perform: true
}
================================================
FILE: .github/pull_request_template.md
================================================
This PR fixes #
================================================
FILE: .github/similarity.yml
================================================
{
perform: true,
whenCreatedByTeam: false,
comment: "(Experimental duplicate detection)\nThanks for submitting this issue. Please also check if it is already covered by an existing one, like:\n${potentialDuplicates}"
}
================================================
FILE: .gitignore
================================================
.DS_Store
.cache
npm-debug.log
Thumbs.db
node_modules/
.build/
extensions/**/dist/
out/
out-build/
out-editor/
out-editor-src/
out-editor-build/
out-editor-esm/
out-editor-min/
out-monaco-editor-core/
out-vscode/
out-vscode-min/
out-vscode-reh/
out-vscode-reh-min/
out-vscode-reh-pkg/
out-vscode-reh-web/
out-vscode-reh-web-min/
out-vscode-reh-web-pkg/
out-vscode-web/
out-vscode-web-min/
src/vs/server
resources/server
build/node_modules
coverage/
test_data/
test-results/
yarn-error.log
.release/
.dockerignore
.idea/workspace.xml
.idea/inspectionProfiles
run.sh
.vs/
*.asar
*.asar.unpacked
*.asarsource
.fast-links
node_modules
.idea/deployment.xml
.idea/typescript-compiler.xml
/data
*.log
.sass-cache
================================================
FILE: .idea/codeStyles/Project.xml
================================================
OVERRIDDEN_METHODS
KEEP
GROUP_PROPERTY_FIELD_WITH_GETTER_SETTER
KEEP
================================================
FILE: .idea/codeStyles/codeStyleConfig.xml
================================================
================================================
FILE: .idea/compiler.xml
================================================
================================================
FILE: .idea/dictionaries/gongt.xml
================================================
baudrate
kendryte
================================================
FILE: .idea/encodings.xml
================================================
================================================
FILE: .idea/misc.xml
================================================
================================================
FILE: .idea/modules.xml
================================================
================================================
FILE: .idea/project.iml
================================================
================================================
FILE: .idea/vcs.xml
================================================
================================================
FILE: .idea/watcherTasks.xml
================================================
================================================
FILE: .mention-bot
================================================
{
"maxReviewers": 2,
"requiredOrgs": ["Microsoft"],
"skipAlreadyAssignedPR": true,
"skipAlreadyMentionedPR": true,
"skipCollaboratorPR": true
}
================================================
FILE: .nvmrc
================================================
10
================================================
FILE: .prettierrc.json
================================================
{
"useTabs": true,
"printWidth": 120,
"semi": true,
"singleQuote": true
}
================================================
FILE: .vscode/cglicenses.schema.json
================================================
{
"type": "array",
"items": {
"oneOf": [
{
"type": "object",
"required": [
"name",
"prependLicenseText"
],
"properties": {
"name": {
"type": "string",
"description": "The name of the dependency"
},
"fullLicenseText": {
"type": "array",
"description": "The complete license text of the dependency",
"items": {
"type": "string"
}
},
"prependLicenseText": {
"type": "array",
"description": "A piece of text to prepend to the auto-detected license text of the dependency",
"items": {
"type": "string"
}
}
}
},
{
"type": "object",
"required": [
"name",
"fullLicenseText"
],
"properties": {
"name": {
"type": "string",
"description": "The name of the dependency"
},
"fullLicenseText": {
"type": "array",
"description": "The complete license text of the dependency",
"items": {
"type": "string"
}
},
"prependLicenseText": {
"type": "array",
"description": "A piece of text to prepend to the auto-detected license text of the dependency",
"items": {
"type": "string"
}
}
}
}
]
}
}
================================================
FILE: .vscode/cgmanifest.schema.json
================================================
{
"type": "object",
"properties": {
"registrations": {
"type": "array",
"items": {
"type": "object",
"properties": {
"component": {
"oneOf": [
{
"type": "object",
"required": [
"type",
"git"
],
"properties": {
"type": {
"type": "string",
"enum": [
"git"
]
},
"git": {
"type": "object",
"required": [
"name",
"repositoryUrl",
"commitHash"
],
"properties": {
"name": {
"type": "string"
},
"repositoryUrl": {
"type": "string"
},
"commitHash": {
"type": "string"
}
}
}
}
},
{
"type": "object",
"required": [
"type",
"npm"
],
"properties": {
"type": {
"type": "string",
"enum": [
"npm"
]
},
"npm": {
"type": "object",
"required": [
"name",
"version"
],
"properties": {
"name": {
"type": "string"
},
"version": {
"type": "string"
}
}
}
}
},
{
"type": "object",
"required": [
"type",
"other"
],
"properties": {
"type": {
"type": "string",
"enum": [
"other"
]
},
"other": {
"type": "object",
"required": [
"name",
"downloadUrl",
"version"
],
"properties": {
"name": {
"type": "string"
},
"downloadUrl": {
"type": "string"
},
"version": {
"type": "string"
}
}
}
}
}
]
},
"repositoryUrl": {
"type": "string",
"description": "The git url of the component"
},
"version": {
"type": "string",
"description": "The version of the component"
},
"license": {
"type": "string",
"description": "The name of the license"
},
"developmentDependency": {
"type": "boolean",
"description": "This component is inlined in the vscode repo and **is not shipped**."
},
"isOnlyProductionDependency": {
"type": "boolean",
"description": "This component is shipped and **is not inlined in the vscode repo**."
},
"licenseDetail": {
"type": "array",
"items": {
"type": "string"
},
"description": "The license text"
}
}
}
}
}
}
================================================
FILE: .vscode/extensions.json
================================================
{
// See https://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format
"recommendations": [
"ms-vscode.vscode-typescript-tslint-plugin",
"dbaeumer.vscode-eslint",
"EditorConfig.EditorConfig",
"msjsdiag.debugger-for-chrome",
"spook.easysass",
]
}
================================================
FILE: .vscode/launch.json
================================================
{
"version": "0.1.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "Gulp Build",
"program": "${workspaceFolder}/node_modules/gulp/bin/gulp.js",
"stopOnEntry": true,
"args": [
"hygiene"
]
},
{
"type": "node",
"request": "attach",
"name": "Attach to Extension Host",
"port": 5870,
"restart": true,
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "chrome",
"request": "attach",
"name": "Attach to Shared Process",
"port": 9222,
"urlFilter": "*"
},
{
"type": "node",
"request": "attach",
"name": "Attach to Search Process",
"port": 5876,
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "node",
"request": "attach",
"name": "Attach to CLI Process",
"port": 5874,
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "node",
"request": "attach",
"name": "Attach to Main Process",
"port": 5875,
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "VS Code Emmet Tests",
"runtimeExecutable": "${execPath}",
"args": [
"${workspaceFolder}/extensions/emmet/test-fixtures",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/emmet",
"--extensionTestsPath=${workspaceFolder}/extensions/emmet/out/test"
],
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "VS Code API Tests (single folder)",
"runtimeExecutable": "${execPath}",
"args": [
// "${workspaceFolder}", // Uncomment for running out of sources.
"${workspaceFolder}/extensions/vscode-api-tests/testWorkspace",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/vscode-api-tests",
"--extensionTestsPath=${workspaceFolder}/extensions/vscode-api-tests/out/singlefolder-tests"
],
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "VS Code API Tests (workspace)",
"runtimeExecutable": "${execPath}",
"args": [
"${workspaceFolder}/extensions/vscode-api-tests/testworkspace.code-workspace",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/vscode-api-tests",
"--extensionTestsPath=${workspaceFolder}/extensions/vscode-api-tests/out/workspace-tests"
],
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "VS Code Tokenizer Tests",
"runtimeExecutable": "${execPath}",
"args": [
"${workspaceFolder}/extensions/vscode-colorize-tests/test",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/vscode-colorize-tests",
"--extensionTestsPath=${workspaceFolder}/extensions/vscode-colorize-tests/out"
],
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "chrome",
"request": "attach",
"name": "Attach to VS Code",
"port": 9222
},
{
"type": "chrome",
"request": "launch",
"name": "Launch VS Code",
"windows": {
"runtimeExecutable": "${workspaceFolder}/scripts/code.bat",
"timeout": 20000
},
"osx": {
"runtimeExecutable": "${workspaceFolder}/scripts/code.sh"
},
"linux": {
"runtimeExecutable": "${workspaceFolder}/scripts/code.sh"
},
"env": {
"VSCODE_EXTHOST_WILL_SEND_SOCKET": null
},
"breakOnLoad": false,
"urlFilter": "*workbench.html*",
"runtimeArgs": [
"--inspect=5875",
"--no-cached-data"
],
"webRoot": "${workspaceFolder}"
},
{
"type": "node",
"request": "launch",
"name": "Launch VS Code (Main Process)",
"runtimeExecutable": "${workspaceFolder}/scripts/code.sh",
"windows": {
"runtimeExecutable": "${workspaceFolder}/scripts/code.bat",
},
"runtimeArgs": [
"--no-cached-data"
],
"outFiles": [
"${workspaceFolder}/out/**/*.js"
]
},
{
"type": "node",
"request": "launch",
"name": "Launch VS Code (Web)",
"runtimeExecutable": "yarn",
"runtimeArgs": [
"web"
],
},
{
"type": "chrome",
"request": "launch",
"name": "Launch VS Code (Web, Chrome)",
"url": "http://localhost:8080",
"preLaunchTask": "Run web"
},
{
"type": "node",
"request": "launch",
"name": "Git Unit Tests",
"program": "${workspaceFolder}/extensions/git/node_modules/mocha/bin/_mocha",
"stopOnEntry": false,
"cwd": "${workspaceFolder}/extensions/git",
"outFiles": [
"${workspaceFolder}/extensions/git/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "Markdown Extension Tests",
"runtimeExecutable": "${execPath}",
"args": [
"${workspaceFolder}/extensions/markdown-language-features/test-fixtures",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/markdown-language-features",
"--extensionTestsPath=${workspaceFolder}/extensions/markdown-language-features/out/test"
],
"outFiles": [
"${workspaceFolder}/extensions/markdown-language-features/out/**/*.js"
]
},
{
"type": "extensionHost",
"request": "launch",
"name": "TypeScript Extension Tests",
"runtimeExecutable": "${execPath}",
"args": [
"${workspaceFolder}/extensions/typescript-language-features/test-fixtures",
"--extensionDevelopmentPath=${workspaceFolder}/extensions/typescript-language-features",
"--extensionTestsPath=${workspaceFolder}/extensions/typescript-language-features/out/test"
],
"outFiles": [
"${workspaceFolder}/extensions/typescript-language-features/out/**/*.js"
]
},
{
"type": "node",
"request": "launch",
"name": "Run Unit Tests",
"program": "${workspaceFolder}/test/electron/index.js",
"runtimeExecutable": "${workspaceFolder}/.build/electron/Code - OSS.app/Contents/MacOS/Electron",
"windows": {
"runtimeExecutable": "${workspaceFolder}/.build/electron/Code - OSS.exe"
},
"linux": {
"runtimeExecutable": "${workspaceFolder}/.build/electron/code-oss"
},
"outputCapture": "std",
"args": [
"--remote-debugging-port=9222"
],
"cwd": "${workspaceFolder}",
"outFiles": [
"${workspaceFolder}/out/**/*.js"
],
"env": {
"MOCHA_COLORS": "true"
}
},
{
"type": "node",
"request": "launch",
"name": "Launch Smoke Test",
"program": "${workspaceFolder}/test/smoke/out/main.js",
"cwd": "${workspaceFolder}/test/smoke",
"timeout": 240000,
"port": 9999,
"args": [
"-l",
"${workspaceFolder}/.build/electron/Code - OSS.app/Contents/MacOS/Electron"
],
"outFiles": [
"${cwd}/out/**/*.js"
],
"env": {
"NODE_ENV": "development",
"VSCODE_DEV": "1",
"VSCODE_CLI": "1"
}
},
{
"name": "Launch Built-in Extension",
"type": "extensionHost",
"request": "launch",
"runtimeExecutable": "${execPath}",
"args": [
"--extensionDevelopmentPath=${workspaceRoot}/extensions/debug-auto-launch"
]
}
],
"compounds": [
{
"name": "Debug VS Code Main and Renderer",
"configurations": [
"Launch VS Code",
"Attach to Main Process"
]
},
{
"name": "Search and Renderer processes",
"configurations": [
"Launch VS Code",
"Attach to Search Process"
]
},
{
"name": "Renderer and Extension Host processes",
"configurations": [
"Launch VS Code",
"Attach to Extension Host"
]
},
{
"name": "Debug Unit Tests",
"configurations": [
"Attach to VS Code",
"Run Unit Tests"
]
},
]
}
================================================
FILE: .vscode/settings.json
================================================
{
"editor.insertSpaces": false,
"files.trimTrailingWhitespace": true,
"files.exclude": {
".git": true,
".build": true,
"**/.DS_Store": true,
"build/**/*.js": {
"when": "$(basename).ts"
}
},
"files.associations": {
"cglicenses.json": "jsonc"
},
"search.exclude": {
"**/node_modules": true,
"**/bower_components": true,
".build/**": true,
"out/**": true,
"out-build/**": true,
"out-vscode/**": true,
"i18n/**": true,
"extensions/**/out/**": true,
"test/smoke/out/**": true,
"src/vs/base/test/node/uri.test.data.txt": true
},
"lcov.path": [
"./.build/coverage/lcov.info",
"./.build/coverage-single/lcov.info"
],
"lcov.watch": [
{
"pattern": "**/*.test.js",
"command": "${workspaceFolder}/scripts/test.sh --coverage --run ${file}",
"windows": {
"command": "${workspaceFolder}\\scripts\\test.bat --coverage --run ${file}"
}
}
],
"typescript.tsdk": "node_modules/typescript/lib",
"npm.exclude": "**/extensions/**",
"emmet.excludeLanguages": [],
"typescript.preferences.importModuleSpecifier": "non-relative",
"typescript.preferences.quoteStyle": "single",
"json.schemas": [
{
"fileMatch": [
"cgmanifest.json"
],
"url": "./.vscode/cgmanifest.schema.json"
},
{
"fileMatch": [
"cglicenses.json"
],
"url": "./.vscode/cglicenses.schema.json"
}
],
"git.ignoreLimitWarning": true,
"remote.extensionKind": {
"msjsdiag.debugger-for-chrome": "workspace"
},
"files.insertFinalNewline": true,
"easysass.formats":[
{
"format": "expanded",
"extension": ".css"
},
]
}
================================================
FILE: .vscode/shared.code-snippets
================================================
{
// Each snippet is defined under a snippet name and has a scope, prefix, body and
// description. The scope defines in watch languages the snippet is applicable. The prefix is what is
// used to trigger the snippet and the body will be expanded and inserted.Possible variables are:
// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders.
// Placeholders with the same ids are connected.
// Example:
"MSFT Copyright Header": {
"scope": "javascript,typescript,css",
"prefix": [
"header",
"stub",
"copyright"
],
"body": [
"/*---------------------------------------------------------------------------------------------",
" * Copyright (c) Microsoft Corporation. All rights reserved.",
" * Licensed under the MIT License. See License.txt in the project root for license information.",
" *--------------------------------------------------------------------------------------------*/",
"",
"$0"
],
"description": "Insert Copyright Statement"
},
"TS -> Inject Service": {
"scope": "typescript",
"description": "Constructor Injection Pattern",
"prefix": "@inject",
"body": "@$1 private readonly _$2: ${1},$0"
},
"TS -> Event & Emitter": {
"scope": "typescript",
"prefix": "emitter",
"description": "Add emitter and event properties",
"body": [
"private readonly _onDid$1 = new Emitter<$2>();",
"readonly onDid$1: Event<$2> = this._onDid$1.event;"
],
}
}
================================================
FILE: .vscode/tasks.json
================================================
{
"version": "2.0.0",
"tasks": [
{
"type": "npm",
"script": "watch",
"label": "Build VS Code",
"group": {
"kind": "build",
"isDefault": true
},
"isBackground": true,
"presentation": {
"reveal": "never"
},
"problemMatcher": {
"owner": "typescript",
"applyTo": "closedDocuments",
"fileLocation": [
"absolute"
],
"pattern": {
"regexp": "Error: ([^(]+)\\((\\d+|\\d+,\\d+|\\d+,\\d+,\\d+,\\d+)\\): (.*)$",
"file": 1,
"location": 2,
"message": 3
},
"background": {
"beginsPattern": "Starting compilation",
"endsPattern": "Finished compilation"
}
}
},
{
"type": "npm",
"script": "strict-initialization-watch",
"label": "TS - Strict Initialization",
"isBackground": true,
"presentation": {
"reveal": "never"
},
"problemMatcher": {
"base": "$tsc-watch",
"owner": "typescript-strict-initialization",
"applyTo": "allDocuments"
}
},
{
"type": "gulp",
"task": "tslint",
"label": "Run tslint",
"problemMatcher": [
"$tslint5"
]
},
{
"label": "Run tests",
"type": "shell",
"command": "./scripts/test.sh",
"windows": {
"command": ".\\scripts\\test.bat"
},
"group": "test",
"presentation": {
"echo": true,
"reveal": "always"
}
},
{
"label": "Run Dev",
"type": "shell",
"command": "./scripts/code.sh",
"windows": {
"command": ".\\scripts\\code.bat"
},
"problemMatcher": []
},
{
"type": "gulp",
"task": "electron",
"label": "Download electron"
},
{
"type": "gulp",
"task": "hygiene",
"problemMatcher": []
},
{
"type": "shell",
"command": "yarn web -- --no-launch",
"label": "Run web",
"isBackground": true,
// This section to make error go away when launching the debug config
"problemMatcher": {
"pattern": {
"regexp": ""
},
"background": {
"beginsPattern": ".*node .*",
"endsPattern": "Web UI available at .*"
}
},
"presentation": {
"reveal": "never"
}
},
]
}
================================================
FILE: .yarnrc
================================================
disturl "https://atom.io/download/electron"
target "6.0.12"
runtime "electron"
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to VS Code
Welcome, and thank you for your interest in contributing to VS Code!
There are many ways in which you can contribute, beyond writing code. The goal of this document is to provide a high-level overview of how you can get involved.
## Asking Questions
Have a question? Rather than opening an issue, please ask away on [Stack Overflow](https://stackoverflow.com/questions/tagged/vscode) using the tag `vscode`.
The active community will be eager to assist you. Your well-worded question will serve as a resource to others searching for help.
## Providing Feedback
Your comments and feedback are welcome, and the development team is available via a handful of different channels.
See the [Feedback Channels](https://github.com/Microsoft/vscode/wiki/Feedback-Channels) wiki page for details on how to share your thoughts.
## Reporting Issues
Have you identified a reproducible problem in VS Code? Have a feature request? We want to hear about it! Here's how you can make reporting your issue as effective as possible.
### Identify Where to Report
The VS Code project is distributed across multiple repositories. Try to file the issue against the correct repository. Check the list of [Related Projects](https://github.com/Microsoft/vscode/wiki/Related-Projects) if you aren't sure which repo is correct.
Can you recreate the issue even after [disabling all extensions](https://code.visualstudio.com/docs/editor/extension-gallery#_disable-an-extension)? If you find the issue is caused by an extension you have installed, please file an issue on the extension's repo directly.
### Look For an Existing Issue
Before you create a new issue, please do a search in [open issues](https://github.com/Microsoft/vscode/issues) to see if the issue or feature request has already been filed.
Be sure to scan through the [most popular](https://github.com/Microsoft/vscode/issues?q=is%3Aopen+is%3Aissue+label%3Afeature-request+sort%3Areactions-%2B1-desc) feature requests.
If you find your issue already exists, make relevant comments and add your [reaction](https://github.com/blog/2119-add-reactions-to-pull-requests-issues-and-comments). Use a reaction in place of a "+1" comment:
* 👍 - upvote
* 👎 - downvote
If you cannot find an existing issue that describes your bug or feature, create a new issue using the guidelines below.
### Writing Good Bug Reports and Feature Requests
File a single issue per problem and feature request. Do not enumerate multiple bugs or feature requests in the same issue.
Do not add your issue as a comment to an existing issue unless it's for the identical input. Many issues look similar, but have different causes.
The more information you can provide, the more likely someone will be successful at reproducing the issue and finding a fix.
The built-in tool for reporting an issue, which you can access by using `Report Issue` in VS Code's Help menu, can help streamline this process by automatically providing the version of VS Code, all your installed extensions, and your system info. Additionally, the tool will search among existing issues to see if a similar issue already exists.
Please include the following with each issue:
* Version of VS Code
* Your operating system
* List of extensions that you have installed
* Reproducible steps (1... 2... 3...) that cause the issue
* What you expected to see, versus what you actually saw
* Images, animations, or a link to a video showing the issue occurring
* A code snippet that demonstrates the issue or a link to a code repository the developers can easily pull down to recreate the issue locally
* **Note:** Because the developers need to copy and paste the code snippet, including a code snippet as a media file (i.e. .gif) is not sufficient.
* Errors from the Dev Tools Console (open from the menu: Help > Toggle Developer Tools)
### Final Checklist
Please remember to do the following:
* [ ] Search the issue repository to ensure your report is a new issue
* [ ] Recreate the issue after disabling all extensions
* [ ] Simplify your code around the issue to better isolate the problem
Don't feel bad if the developers can't reproduce the issue right away. They will simply ask for more information!
### Follow Your Issue
Once submitted, your report will go into the [issue tracking](https://github.com/Microsoft/vscode/wiki/Issue-Tracking) workflow. Be sure to understand what will happen next, so you know what to expect, and how to continue to assist throughout the process.
## Automated Issue Management
We use a bot to help us manage issues. This bot currently:
* Automatically closes any issue marked `needs-more-info` if there has been no response in the past 7 days.
* Automatically locks issues 45 days after they are closed.
If you believe the bot got something wrong, please open a new issue and let us know.
## Contributing Fixes
If you are interested in writing code to fix issues,
please see [How to Contribute](https://github.com/Microsoft/vscode/wiki/How-to-Contribute) in the wiki.
# Thank You!
Your contributions to open source, large or small, make great projects like this possible. Thank you for taking the time to contribute.
================================================
FILE: LICENSE.txt
================================================
## Visual Studio Code:
[MIT](https://github.com/Microsoft/vscode/blob/master/LICENSE.txt)
## Visual Studio 2017 Image Library:
[Microsoft Software License Terms](http://download.microsoft.com/download/0/6/0/0607D8EA-9BB7-440B-A36A-A24EB8C9C67E/Visual%20Studio%202017%20Image%20Library%20EULA.RTF)
================================================
FILE: README.md
================================================
# Kendryte IDE
[![Download Beta Version][Beta Version Badage]][Beta Version Download Page]
[![Download Alpha Version][Alpha Version Badage]][Alpha Version Download Page]
👈 Click open download page
Based on a excellent🎉 editor [Visual Studio Code](https://github.com/Microsoft/vscode)
**下方内容仅供IDE开发参考，如需使用IDE，请点击上方 `Alpha` `Beta` 按钮下载**
## Status (azure pipelines)
Alpha version
----
| Item | Build Status |
|-----|-----|
| Main Application | [![MainApplication][Alpha MainApplication Image]][Alpha MainApplication Link] |
| Updater | [![Updater][Alpha Updater Image]][Alpha Updater Link] |
| Released Application | [![ReleasedApplication][Alpha ReleasedApplication Image]][Alpha ReleasedApplication Link] |
| Index Page | [![IndexPage][Alpha IndexPage Image]][Alpha IndexPage Link] |
| Platform | Status |
|-----|-----|
| Windows | [![Windows][Alpha Windows Image]][Alpha Windows Link] |
| Linux | [![Linux][Alpha Linux Image]][Alpha Linux Link] |
| Darwin | [![Darwin][Alpha Darwin Image]][Alpha Darwin Link] |
Beta version
----
| Project | Build Status |
|-----|-----|
| Main Application | [![MainApplication][Beta MainApplication Image]][Beta MainApplication Link] |
| Updater | [![Updater][Beta Updater Image]][Beta Updater Link] |
| Released Application | [![ReleasedApplication][Beta ReleasedApplication Image]][Beta ReleasedApplication Link] |
| Index Page | [![IndexPage][Beta IndexPage Image]][Beta IndexPage Link] |
| Platform | Status |
|-----|-----|
| Windows | [![Windows][Beta Windows Image]][Beta Windows Link] |
| Linux | [![Linux][Beta Linux Image]][Beta Linux Link] |
| Darwin | [![Darwin][Beta Darwin Image]][Beta Darwin Link] |
Offline Packages
----
[![Offline Packages][Offline Packages Image]][Offline Packages Link]
### Resources
* [Forum](https://forum.kendryte.com/)
* [FAQ](https://github.com/kendryte/kendryte-ide/wiki/FAQ)
### Development
[README](https://github.com/kendryte/kendryte-ide/wiki/README.en)
[读我](https://github.com/kendryte/kendryte-ide/wiki/README.cn)
[Offline Packages Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/OfflinePackages?branchName=master
[Offline Packages Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=11?branchName=master
[Alpha MainApplication Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Kendryte%20IDE%20Main%20(Alpha)?branchName=development
[Alpha MainApplication Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=10?branchName=development
[Alpha Windows Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Kendryte%20IDE%20Main%20(Alpha)?branchName=development&jobName=Windows
[Alpha Windows Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=10?branchName=development
[Alpha Linux Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Kendryte%20IDE%20Main%20(Alpha)?branchName=development&jobName=Linux
[Alpha Linux Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=10?branchName=development
[Alpha Darwin Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Kendryte%20IDE%20Main%20(Alpha)?branchName=development&jobName=Darwin
[Alpha Darwin Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=10?branchName=development
[Alpha Updater Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Updater%20(Alpha)?branchName=master
[Alpha Updater Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=3?branchName=master
[Alpha ReleasedApplication Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Kendryte%20IDE%20Merge%20(Alpha)?branchName=master
[Alpha ReleasedApplication Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=13?branchName=master
[Alpha IndexPage Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Alpha/Update%20Download%20Page%20(Alpha)?branchName=master
[Alpha IndexPage Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=15?branchName=master
[Beta MainApplication Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Kendryte%20IDE%20Main%20(Beta)?branchName=development
[Beta MainApplication Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=30?branchName=development
[Beta Windows Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Kendryte%20IDE%20Main%20(Beta)?branchName=development&jobName=Windows
[Beta Windows Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=30?branchName=development
[Beta Linux Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Kendryte%20IDE%20Main%20(Beta)?branchName=development&jobName=Linux
[Beta Linux Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=30?branchName=development
[Beta Darwin Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Kendryte%20IDE%20Main%20(Beta)?branchName=development&jobName=Darwin
[Beta Darwin Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=30?branchName=development
[Beta Updater Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Updater%20(Beta)?branchName=master
[Beta Updater Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=34?branchName=master
[Beta ReleasedApplication Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Kendryte%20IDE%20Merge%20(Beta)?branchName=master
[Beta ReleasedApplication Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=31?branchName=master
[Beta IndexPage Image]: https://gongt.visualstudio.com/kendryte-ide/_apis/build/status/Beta/Update%20Download%20Page%20(Beta)?branchName=master
[Beta IndexPage Link]: https://gongt.visualstudio.com/kendryte-ide/_build/latest?definitionId=33?branchName=master
[Beta Version Badage]: https://kendryte-ide.s3.cn-northwest-1.amazonaws.com.cn/badges/beta.badge.svg
[Beta Version Download Page]: http://kendryte-ide.s3-website.cn-northwest-1.amazonaws.com.cn/
[Alpha Version Badage]: https://kendryte-ide.s3.cn-northwest-1.amazonaws.com.cn/badges/alpha.badge.svg
[Alpha Version Download Page]: http://kendryte-ide.s3-website.cn-northwest-1.amazonaws.com.cn/alpha.html
================================================
FILE: ThirdPartyNotices.txt
================================================
microsoft-vscode
THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
Do Not Translate or Localize
This project incorporates components from the projects listed below. The original copyright notices and the licenses under which Microsoft received such components are set forth below. Microsoft reserves all rights not expressly granted herein, whether by implication, estoppel or otherwise.
1. atom/language-clojure version 0.22.7 (https://github.com/atom/language-clojure)
2. atom/language-coffee-script version 0.49.3 (https://github.com/atom/language-coffee-script)
3. atom/language-java version 0.31.3 (https://github.com/atom/language-java)
4. atom/language-sass version 0.61.4 (https://github.com/atom/language-sass)
5. atom/language-shellscript version 0.26.0 (https://github.com/atom/language-shellscript)
6. atom/language-xml version 0.35.2 (https://github.com/atom/language-xml)
7. Colorsublime-Themes version 0.1.0 (https://github.com/Colorsublime/Colorsublime-Themes)
8. daaain/Handlebars version 1.8.0 (https://github.com/daaain/Handlebars)
9. davidrios/pug-tmbundle (https://github.com/davidrios/pug-tmbundle)
10. definitelytyped (https://github.com/DefinitelyTyped/DefinitelyTyped)
11. demyte/language-cshtml version 0.3.0 (https://github.com/demyte/language-cshtml)
12. Document Object Model version 4.0.0 (https://www.w3.org/DOM/)
13. dotnet/csharp-tmLanguage version 0.1.0 (https://github.com/dotnet/csharp-tmLanguage)
14. expand-abbreviation version 0.5.8 (https://github.com/emmetio/expand-abbreviation)
15. fadeevab/make.tmbundle (https://github.com/fadeevab/make.tmbundle)
16. freebroccolo/atom-language-swift (https://github.com/freebroccolo/atom-language-swift)
17. HTML 5.1 W3C Working Draft version 08 October 2015 (http://www.w3.org/TR/2015/WD-html51-20151008/)
18. Ikuyadeu/vscode-R version 0.5.5 (https://github.com/Ikuyadeu/vscode-R)
19. insane version 2.6.2 (https://github.com/bevacqua/insane)
20. Ionic documentation version 1.2.4 (https://github.com/ionic-team/ionic-site)
21. ionide/ionide-fsgrammar (https://github.com/ionide/ionide-fsgrammar)
22. jeff-hykin/cpp-textmate-grammar version 1.12.11 (https://github.com/jeff-hykin/cpp-textmate-grammar)
23. jeff-hykin/cpp-textmate-grammar version 1.14.6 (https://github.com/jeff-hykin/cpp-textmate-grammar)
24. js-beautify version 1.6.8 (https://github.com/beautify-web/js-beautify)
25. Jxck/assert version 1.0.0 (https://github.com/Jxck/assert)
26. language-docker (https://github.com/moby/moby)
27. language-go version 0.44.3 (https://github.com/atom/language-go)
28. language-less version 0.34.2 (https://github.com/atom/language-less)
29. language-php version 0.44.1 (https://github.com/atom/language-php)
30. language-rust version 0.4.12 (https://github.com/zargony/atom-language-rust)
31. MagicStack/MagicPython version 1.1.1 (https://github.com/MagicStack/MagicPython)
32. marked version 0.6.2 (https://github.com/markedjs/marked)
33. mdn-data version 1.1.12 (https://github.com/mdn/data)
34. Microsoft/TypeScript-TmLanguage version 0.0.1 (https://github.com/Microsoft/TypeScript-TmLanguage)
35. Microsoft/vscode-JSON.tmLanguage (https://github.com/Microsoft/vscode-JSON.tmLanguage)
36. Microsoft/vscode-mssql version 1.6.0 (https://github.com/Microsoft/vscode-mssql)
37. mmims/language-batchfile version 0.7.5 (https://github.com/mmims/language-batchfile)
38. octicons version 8.3.0 (https://github.com/primer/octicons)
39. octref/language-css version 0.42.11 (https://github.com/octref/language-css)
40. PowerShell/EditorSyntax version 1.0.0 (https://github.com/PowerShell/EditorSyntax)
41. promise-polyfill version 8.0.0 (https://github.com/taylorhakes/promise-polyfill)
42. seti-ui version 0.1.0 (https://github.com/jesseweed/seti-ui)
43. shaders-tmLanguage version 0.1.0 (https://github.com/tgjones/shaders-tmLanguage)
44. textmate/asp.vb.net.tmbundle (https://github.com/textmate/asp.vb.net.tmbundle)
45. textmate/c.tmbundle (https://github.com/textmate/c.tmbundle)
46. textmate/diff.tmbundle (https://github.com/textmate/diff.tmbundle)
47. textmate/git.tmbundle (https://github.com/textmate/git.tmbundle)
48. textmate/groovy.tmbundle (https://github.com/textmate/groovy.tmbundle)
49. textmate/html.tmbundle (https://github.com/textmate/html.tmbundle)
50. textmate/ini.tmbundle (https://github.com/textmate/ini.tmbundle)
51. textmate/javascript.tmbundle (https://github.com/textmate/javascript.tmbundle)
52. textmate/lua.tmbundle (https://github.com/textmate/lua.tmbundle)
53. textmate/markdown.tmbundle (https://github.com/textmate/markdown.tmbundle)
54. textmate/perl.tmbundle (https://github.com/textmate/perl.tmbundle)
55. textmate/ruby.tmbundle (https://github.com/textmate/ruby.tmbundle)
56. textmate/yaml.tmbundle (https://github.com/textmate/yaml.tmbundle)
57. TypeScript-TmLanguage version 0.1.8 (https://github.com/Microsoft/TypeScript-TmLanguage)
58. TypeScript-TmLanguage version 1.0.0 (https://github.com/Microsoft/TypeScript-TmLanguage)
59. Unicode version 12.0.0 (http://www.unicode.org/)
60. vscode-logfile-highlighter version 2.4.1 (https://github.com/emilast/vscode-logfile-highlighter)
61. vscode-octicons-font version 1.3.2 (https://github.com/Microsoft/vscode-octicons-font)
62. vscode-swift version 0.0.1 (https://github.com/owensd/vscode-swift)
63. Web Background Synchronization (https://github.com/WICG/BackgroundSync)
%% atom/language-clojure NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/mmcgrana/textmate-clojure and distributed under the
following license, located in `LICENSE.md`:
The MIT License (MIT)
Copyright (c) 2010- Mark McGranaghan
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF atom/language-clojure NOTICES AND INFORMATION
%% atom/language-coffee-script NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/jashkenas/coffee-script-tmbundle and distributed under the
following license, located in `LICENSE`:
Copyright (c) 2009-2014 Jeremy Ashkenas
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF atom/language-coffee-script NOTICES AND INFORMATION
%% atom/language-java NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/java.tmbundle and distributed under the following
license, located in `README.mdown`:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
=========================================
END OF atom/language-java NOTICES AND INFORMATION
%% atom/language-sass NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/alexsancho/Sass.tmbundle and distributed under the following
license, located in `LICENSE.md`:
Copyright (c) 2012 Alex Sancho, http://alexsancho.name/
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF atom/language-sass NOTICES AND INFORMATION
%% atom/language-shellscript NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/shellscript.tmbundle and distributed under the
following license, located in `README.mdown`:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
=========================================
END OF atom/language-shellscript NOTICES AND INFORMATION
%% atom/language-xml NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/xml.tmbundle and distributed under the following
license, located in `README.mdown`:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
=========================================
END OF atom/language-xml NOTICES AND INFORMATION
%% Colorsublime-Themes NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) 2015 Colorsublime.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF Colorsublime-Themes NOTICES AND INFORMATION
%% daaain/Handlebars NOTICES AND INFORMATION BEGIN HERE
=========================================
-- Credits
Adapted from the great sublime-text-handlebars package by Nicholas Westlake.
Thanks a lot to all the generous contributors (in alphabetical order): @bittersweetryan, @bradcliffe, @calumbrodie, @duncanbeevers, @hlvnst, @jonschlinkert, @Krutius, @samselikoff, @utkarshkukreti, @zeppelin
-- License
(The MIT License)
Copyright (c) daaain/Handlebars project authors
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF daaain/Handlebars NOTICES AND INFORMATION
%% davidrios/pug-tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2016 David Rios
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF davidrios/pug-tmbundle NOTICES AND INFORMATION
%% definitelytyped NOTICES AND INFORMATION BEGIN HERE
=========================================
This project is licensed under the MIT license.
Copyrights are respective of each contributor listed at the beginning of each definition file.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF definitelytyped NOTICES AND INFORMATION
%% demyte/language-cshtml NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 James Summerton
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF demyte/language-cshtml NOTICES AND INFORMATION
%% Document Object Model NOTICES AND INFORMATION BEGIN HERE
=========================================
W3C License
This work is being provided by the copyright holders under the following license.
By obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions.
Permission to copy, modify, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following
on ALL copies of the work or portions thereof, including modifications:
* The full text of this NOTICE in a location viewable to users of the redistributed or derivative work.
* Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software and Document Short Notice should be included.
* Notice of any changes or modifications, through a copyright statement on the new code or document such as "This software or document includes material copied from or derived
from Document Object Model. Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang)."
Disclaimers
THIS WORK IS PROVIDED "AS IS
AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR
FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT.
The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission.
Title to copyright in this work will at all times remain with copyright holders.
=========================================
END OF Document Object Model NOTICES AND INFORMATION
%% dotnet/csharp-tmLanguage NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2016 .NET Foundation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF dotnet/csharp-tmLanguage NOTICES AND INFORMATION
%% expand-abbreviation NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2017 Emmet.io
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF expand-abbreviation NOTICES AND INFORMATION
%% fadeevab/make.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-make.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF fadeevab/make.tmbundle NOTICES AND INFORMATION
%% freebroccolo/atom-language-swift NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 Darin Morrison
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF freebroccolo/atom-language-swift NOTICES AND INFORMATION
%% HTML 5.1 W3C Working Draft NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright © 2015 W3C® (MIT, ERCIM, Keio, Beihang). This software or document includes material copied
from or derived from HTML 5.1 W3C Working Draft (http://www.w3.org/TR/2015/WD-html51-20151008/.)
THIS DOCUMENT IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT
NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF
THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY
PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE
DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF.
The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to this document or its contents
without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders.
=========================================
END OF HTML 5.1 W3C Working Draft NOTICES AND INFORMATION
%% Ikuyadeu/vscode-R NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2017 Yuki Ueda
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF Ikuyadeu/vscode-R NOTICES AND INFORMATION
%% insane NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright © 2015 Nicolas Bevacqua
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF insane NOTICES AND INFORMATION
%% Ionic documentation NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright Drifty Co. http://drifty.com/.
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
You must give any other recipients of the Work or Derivative Works a copy of this License; and
You must cause any modified files to carry prominent notices stating that You changed the files; and
You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
=========================================
END OF Ionic documentation NOTICES AND INFORMATION
%% ionide/ionide-fsgrammar NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2015 Krzysztof Cieslak
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF ionide/ionide-fsgrammar NOTICES AND INFORMATION
%% jeff-hykin/cpp-textmate-grammar NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2019 Jeff Hykin
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF jeff-hykin/cpp-textmate-grammar NOTICES AND INFORMATION
%% js-beautify NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF js-beautify NOTICES AND INFORMATION
%% Jxck/assert NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2011 Jxck
Originally from node.js (http://nodejs.org)
Copyright Joyent, Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF Jxck/assert NOTICES AND INFORMATION
%% language-docker NOTICES AND INFORMATION BEGIN HERE
=========================================
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
Copyright 2013-2018 Docker, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================
END OF language-docker NOTICES AND INFORMATION
%% language-go NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/rsms/Go.tmbundle and distributed under the following
license, located in `LICENSE`:
Copyright (c) 2009 Rasmus Andersson
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
The Go Template grammar was derived from GoSublime located at
https://github.com/DisposaBoy/GoSublime and distributed under the following
license, located in `LICENSE.md`:
Copyright (c) 2012 The GoSublime Authors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF language-go NOTICES AND INFORMATION
%% language-less NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/less.tmbundle and distributed under the following
license, located in `LICENSE.md`:
Copyright (c) 2010 Scott Kyle and Rasmus Andersson
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF language-less NOTICES AND INFORMATION
%% language-php NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/php.tmbundle and distributed under the following
license, located in `README.mdown`:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
=========================================
END OF language-php NOTICES AND INFORMATION
%% language-rust NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright © `2013` `Andreas Neuhaus` `http://zargony.com/`
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF language-rust NOTICES AND INFORMATION
%% MagicStack/MagicPython NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License
Copyright (c) 2015-present MagicStack Inc. http://magic.io
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF MagicStack/MagicPython NOTICES AND INFORMATION
%% marked NOTICES AND INFORMATION BEGIN HERE
=========================================
information
## Contribution License Agreement
If you contribute code to this project, you are implicitly allowing your code
to be distributed under the MIT license. You are also implicitly verifying that
all code is your original work. ``
## Marked
Copyright (c) 2011-2018, Christopher Jeffrey (https://github.com/chjj/)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
## Markdown
Copyright © 2004, John Gruber
http://daringfireball.net/
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name "Markdown" nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright owner or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.
=========================================
END OF marked NOTICES AND INFORMATION
%% mdn-data NOTICES AND INFORMATION BEGIN HERE
=========================================
Mozilla Public License Version 2.0
Copyright (c) 2018 Mozilla Corporation
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
(a) that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
(b) that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
(a) any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
(b) any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
(a) under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
(b) under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
(a) for any code that a Contributor has removed from Covered Software;
or
(b) for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
(c) under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
(a) such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
(b) You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under Section
2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
************************************************************************
* *
* 6. Disclaimer of Warranty *
* ------------------------- *
* *
* Covered Software is provided under this License on an "as is" *
* basis, without warranty of any kind, either expressed, implied, or *
* statutory, including, without limitation, warranties that the *
* Covered Software is free of defects, merchantable, fit for a *
* particular purpose or non-infringing. The entire risk as to the *
* quality and performance of the Covered Software is with You. *
* Should any Covered Software prove defective in any respect, You *
* (not any Contributor) assume the cost of any necessary servicing, *
* repair, or correction. This disclaimer of warranty constitutes an *
* essential part of this License. No use of any Covered Software is *
* authorized under this License except under this disclaimer. *
* *
************************************************************************
************************************************************************
* *
* 7. Limitation of Liability *
* -------------------------- *
* *
* Under no circumstances and under no legal theory, whether tort *
* (including negligence), contract, or otherwise, shall any *
* Contributor, or anyone who distributes Covered Software as *
* permitted above, be liable to You for any direct, indirect, *
* special, incidental, or consequential damages of any character *
* including, without limitation, damages for lost profits, loss of *
* goodwill, work stoppage, computer failure or malfunction, or any *
* and all other commercial damages or losses, even if such party *
* shall have been informed of the possibility of such damages. This *
* limitation of liability shall not apply to liability for death or *
* personal injury resulting from such party's negligence to the *
* extent applicable law prohibits such limitation. Some *
* jurisdictions do not allow the exclusion or limitation of *
* incidental or consequential damages, so this exclusion and *
* limitation may not apply to You. *
* *
************************************************************************
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in Section
10.3, no one other than the license steward has the right to modify or
publish new versions of this License. Each version will be given a
distinguishing version number.
10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
10.4. Distributing Source Code Form that is Incompatible With Secondary
Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
If it is not possible or desirable to put the notice in a particular
file, then You may include the notice in a location (such as a LICENSE
file in a relevant directory) where a recipient would be likely to look
for such a notice.
You may add additional accurate notices of copyright ownership.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
This Source Code Form is "Incompatible With Secondary Licenses", as
defined by the Mozilla Public License, v. 2.0.
=========================================
END OF mdn-data NOTICES AND INFORMATION
%% Microsoft/TypeScript-TmLanguage NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF Microsoft/TypeScript-TmLanguage NOTICES AND INFORMATION
%% Microsoft/vscode-JSON.tmLanguage NOTICES AND INFORMATION BEGIN HERE
=========================================
vscode-JSON.tmLanguage
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
documentation files (the ""Software""), to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF Microsoft/vscode-JSON.tmLanguage NOTICES AND INFORMATION
%% Microsoft/vscode-mssql NOTICES AND INFORMATION BEGIN HERE
=========================================
------------------------------------------ START OF LICENSE -----------------------------------------
vscode-mssql
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
Copyright (c) 2016 Sanjay Nagamangalam
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
----------------------------------------------- END OF LICENSE ------------------------------------------
=========================================
END OF Microsoft/vscode-mssql NOTICES AND INFORMATION
%% mmims/language-batchfile NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2017 Michael Mims
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF mmims/language-batchfile NOTICES AND INFORMATION
%% octicons NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2019 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF octicons NOTICES AND INFORMATION
%% octref/language-css NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 GitHub Inc.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This package was derived from a TextMate bundle located at
https://github.com/textmate/css.tmbundle and distributed under the following
license, located in `README.mdown`:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
=========================================
END OF octref/language-css NOTICES AND INFORMATION
%% PowerShell/EditorSyntax NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF PowerShell/EditorSyntax NOTICES AND INFORMATION
%% promise-polyfill NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2014 Taylor Hakes
Copyright (c) 2014 Forbes Lindesay
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF promise-polyfill NOTICES AND INFORMATION
%% seti-ui NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) 2014 Jesse Weed
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF seti-ui NOTICES AND INFORMATION
%% shaders-tmLanguage NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) 2017 Tim Jones
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF shaders-tmLanguage NOTICES AND INFORMATION
%% textmate/asp.vb.net.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-asp.vb.net.tmbundle project authors
If not otherwise specified (see below), files in this folder fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/asp.vb.net.tmbundle NOTICES AND INFORMATION
%% textmate/c.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-c.tmbundle authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/c.tmbundle NOTICES AND INFORMATION
%% textmate/diff.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-diff.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/diff.tmbundle NOTICES AND INFORMATION
%% textmate/git.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2008 Tim Harper
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the"
Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF textmate/git.tmbundle NOTICES AND INFORMATION
%% textmate/groovy.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-groovy.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/groovy.tmbundle NOTICES AND INFORMATION
%% textmate/html.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-html.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/html.tmbundle NOTICES AND INFORMATION
%% textmate/ini.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-ini.tmbundle project authors
If not otherwise specified (see below), files in this folder fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/ini.tmbundle NOTICES AND INFORMATION
%% textmate/javascript.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-javascript.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/javascript.tmbundle NOTICES AND INFORMATION
%% textmate/lua.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-lua.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/lua.tmbundle NOTICES AND INFORMATION
%% textmate/markdown.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) markdown.tmbundle authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/markdown.tmbundle NOTICES AND INFORMATION
%% textmate/perl.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-perl.tmbundle project authors
If not otherwise specified (see below), files in this repository fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/perl.tmbundle NOTICES AND INFORMATION
%% textmate/ruby.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) textmate-ruby.tmbundle project authors
If not otherwise specified (see below), files in this folder fall under the following license:
Permission to copy, use, modify, sell and distribute this
software is granted. This software is provided "as is" without
express or implied warranty, and with no claim as to its
suitability for any purpose.
An exception is made for files in readable text which contain their own license information,
or files where an accompanying file exists (in the same directory) with a "-license" suffix added
to the base-name name of the original file, and an extension of txt, html, or similar. For example
"tidy" is accompanied by "tidy-license.txt".
=========================================
END OF textmate/ruby.tmbundle NOTICES AND INFORMATION
%% textmate/yaml.tmbundle NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) 2015 FichteFoll
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF textmate/yaml.tmbundle NOTICES AND INFORMATION
%% TypeScript-TmLanguage NOTICES AND INFORMATION BEGIN HERE
=========================================
Copyright (c) Microsoft Corporation
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
=========================================
END OF TypeScript-TmLanguage NOTICES AND INFORMATION
%% Unicode NOTICES AND INFORMATION BEGIN HERE
=========================================
Unicode Data Files include all data files under the directories
http://www.unicode.org/Public/, http://www.unicode.org/reports/,
http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
http://www.unicode.org/utility/trac/browser/.
Unicode Data Files do not include PDF online code charts under the
directory http://www.unicode.org/Public/.
Software includes any source code published in the Unicode Standard
or under the directories
http://www.unicode.org/Public/, http://www.unicode.org/reports/,
http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
http://www.unicode.org/utility/trac/browser/.
NOTICE TO USER: Carefully read the following legal agreement.
BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
TERMS AND CONDITIONS OF THIS AGREEMENT.
IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
THE DATA FILES OR SOFTWARE.
COPYRIGHT AND PERMISSION NOTICE
Copyright (c) 1991-2017 Unicode, Inc. All rights reserved.
Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Unicode data files and any associated documentation
(the "Data Files") or Unicode software and any associated documentation
(the "Software") to deal in the Data Files or Software
without restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, and/or sell copies of
the Data Files or Software, and to permit persons to whom the Data Files
or Software are furnished to do so, provided that either
(a) this copyright and permission notice appear with all copies
of the Data Files or Software, or
(b) this copyright and permission notice appear in associated
Documentation.
THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT OF THIRD PARTY RIGHTS.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THE DATA FILES OR SOFTWARE.
Except as contained in this notice, the name of a copyright holder
shall not be used in advertising or otherwise to promote the sale,
use or other dealings in these Data Files or Software without prior
written authorization of the copyright holder.
=========================================
END OF Unicode NOTICES AND INFORMATION
%% vscode-logfile-highlighter NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2015 emilast
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
=========================================
END OF vscode-logfile-highlighter NOTICES AND INFORMATION
%% vscode-octicons-font NOTICES AND INFORMATION BEGIN HERE
=========================================
MIT License
Copyright (c) Microsoft Corporation. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE
=========================================
END OF vscode-octicons-font NOTICES AND INFORMATION
%% vscode-swift NOTICES AND INFORMATION BEGIN HERE
=========================================
The MIT License (MIT)
Copyright (c) 2015 David Owens II
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
=========================================
END OF vscode-swift NOTICES AND INFORMATION
%% Web Background Synchronization NOTICES AND INFORMATION BEGIN HERE
=========================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "{}"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright {yyyy} {name of copyright owner}
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================
END OF Web Background Synchronization NOTICES AND INFORMATION
================================================
FILE: azure-pipelines.yml
================================================
jobs:
- job: Windows
pool:
vmImage: VS2017-Win2016
steps:
- template: build/azure-pipelines/win32/continuous-build-win32.yml
- job: Linux
pool:
vmImage: 'Ubuntu-16.04'
steps:
- template: build/azure-pipelines/linux/continuous-build-linux.yml
- job: macOS
pool:
vmImage: macOS 10.13
steps:
- template: build/azure-pipelines/darwin/continuous-build-darwin.yml
================================================
FILE: build/.cachesalt
================================================
2019-08-30T20:24:23.714Z
================================================
FILE: build/.nativeignore
================================================
# cleanup rules for native node modules, .gitignore style
nan/**
*/node_modules/nan/**
fsevents/binding.gyp
fsevents/fsevents.cc
fsevents/build/**
fsevents/src/**
fsevents/test/**
!fsevents/**/*.node
vscode-sqlite3/binding.gyp
vscode-sqlite3/benchmark/**
vscode-sqlite3/cloudformation/**
vscode-sqlite3/deps/**
vscode-sqlite3/test/**
vscode-sqlite3/build/**
vscode-sqlite3/src/**
!vscode-sqlite3/build/Release/*.node
oniguruma/binding.gyp
oniguruma/build/**
oniguruma/src/**
oniguruma/deps/**
!oniguruma/build/Release/*.node
!oniguruma/src/*.js
windows-mutex/binding.gyp
windows-mutex/build/**
windows-mutex/src/**
!windows-mutex/**/*.node
native-keymap/binding.gyp
native-keymap/build/**
native-keymap/src/**
native-keymap/deps/**
!native-keymap/build/Release/*.node
native-is-elevated/binding.gyp
native-is-elevated/build/**
native-is-elevated/src/**
native-is-elevated/deps/**
!native-is-elevated/build/Release/*.node
native-watchdog/binding.gyp
native-watchdog/build/**
native-watchdog/src/**
!native-watchdog/build/Release/*.node
spdlog/binding.gyp
spdlog/build/**
spdlog/deps/**
spdlog/src/**
spdlog/test/**
!spdlog/build/Release/*.node
jschardet/dist/**
windows-foreground-love/binding.gyp
windows-foreground-love/build/**
windows-foreground-love/src/**
!windows-foreground-love/**/*.node
windows-process-tree/binding.gyp
windows-process-tree/build/**
windows-process-tree/src/**
!windows-process-tree/**/*.node
keytar/binding.gyp
keytar/build/**
keytar/src/**
keytar/script/**
keytar/node_modules/**
!keytar/**/*.node
node-pty/binding.gyp
node-pty/build/**
node-pty/src/**
node-pty/tools/**
node-pty/deps/**
!node-pty/build/Release/*.exe
!node-pty/build/Release/*.dll
!node-pty/build/Release/*.node
nsfw/binding.gyp
nsfw/build/**
nsfw/src/**
nsfw/openpa/**
nsfw/includes/**
!nsfw/build/Release/*.node
!nsfw/**/*.a
vsda/build/**
vsda/ci/**
vsda/src/**
vsda/.gitignore
vsda/binding.gyp
vsda/README.md
vsda/targets
!vsda/build/Release/vsda.node
vscode-windows-ca-certs/**/*
!vscode-windows-ca-certs/package.json
!vscode-windows-ca-certs/**/*.node
node-addon-api/**/*
lzma-native/build/**
lzma-native/src/**
lzma-native/deps/**
lzma-native/binding.gyp
lzma-native/*.sh
lzma-native/*.md*
!lzma-native/**/*.dll
!lzma-native/**/*.node
================================================
FILE: build/azure-pipelines/common/.gitignore
================================================
node_modules/
*.js
================================================
FILE: build/azure-pipelines/common/extract-telemetry.sh
================================================
#!/usr/bin/env bash
set -e
cd $BUILD_STAGINGDIRECTORY
mkdir extraction
cd extraction
git clone --depth 1 https://github.com/Microsoft/vscode-extension-telemetry.git
git clone --depth 1 https://github.com/Microsoft/vscode-chrome-debug-core.git
git clone --depth 1 https://github.com/Microsoft/vscode-node-debug2.git
git clone --depth 1 https://github.com/Microsoft/vscode-node-debug.git
git clone --depth 1 https://github.com/Microsoft/vscode-html-languageservice.git
git clone --depth 1 https://github.com/Microsoft/vscode-json-languageservice.git
$BUILD_SOURCESDIRECTORY/build/node_modules/.bin/vscode-telemetry-extractor --sourceDir $BUILD_SOURCESDIRECTORY --excludedDir $BUILD_SOURCESDIRECTORY/extensions --outputDir . --applyEndpoints
$BUILD_SOURCESDIRECTORY/build/node_modules/.bin/vscode-telemetry-extractor --config $BUILD_SOURCESDIRECTORY/build/azure-pipelines/common/telemetry-config.json -o .
mkdir -p $BUILD_SOURCESDIRECTORY/.build/telemetry
mv declarations-resolved.json $BUILD_SOURCESDIRECTORY/.build/telemetry/telemetry-core.json
mv config-resolved.json $BUILD_SOURCESDIRECTORY/.build/telemetry/telemetry-extensions.json
cd ..
rm -rf extraction
================================================
FILE: build/azure-pipelines/common/publish-webview.sh
================================================
#!/usr/bin/env bash
set -e
REPO="$(pwd)"
# Publish webview contents
PACKAGEJSON="$REPO/package.json"
VERSION=$(node -p "require(\"$PACKAGEJSON\").version")
node build/azure-pipelines/common/publish-webview.js "$REPO/src/vs/workbench/contrib/webview/browser/pre/"
================================================
FILE: build/azure-pipelines/common/publish-webview.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as azure from 'azure-storage';
import * as mime from 'mime';
import * as minimist from 'minimist';
import { basename, join } from 'path';
const fileNames = [
'fake.html',
'host.js',
'index.html',
'main.js',
'service-worker.js'
];
async function assertContainer(blobService: azure.BlobService, container: string): Promise {
await new Promise((c, e) => blobService.createContainerIfNotExists(container, { publicAccessLevel: 'blob' }, err => err ? e(err) : c()));
}
async function doesBlobExist(blobService: azure.BlobService, container: string, blobName: string): Promise {
const existsResult = await new Promise((c, e) => blobService.doesBlobExist(container, blobName, (err, r) => err ? e(err) : c(r)));
return existsResult.exists;
}
async function uploadBlob(blobService: azure.BlobService, container: string, blobName: string, file: string): Promise {
const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
contentSettings: {
contentType: mime.lookup(file),
cacheControl: 'max-age=31536000, public'
}
};
await new Promise((c, e) => blobService.createBlockBlobFromLocalFile(container, blobName, file, blobOptions, err => err ? e(err) : c()));
}
async function publish(commit: string, files: readonly string[]): Promise {
console.log('Publishing...');
console.log('Commit:', commit);
const storageAccount = process.env['AZURE_WEBVIEW_STORAGE_ACCOUNT']!;
const blobService = azure.createBlobService(storageAccount, process.env['AZURE_WEBVIEW_STORAGE_ACCESS_KEY']!)
.withFilter(new azure.ExponentialRetryPolicyFilter(20));
await assertContainer(blobService, commit);
for (const file of files) {
const blobName = basename(file);
const blobExists = await doesBlobExist(blobService, commit, blobName);
if (blobExists) {
console.log(`Blob ${commit}, ${blobName} already exists, not publishing again.`);
continue;
}
console.log('Uploading blob to Azure storage...');
await uploadBlob(blobService, commit, blobName, file);
}
console.log('Blobs successfully uploaded.');
}
function main(): void {
const commit = process.env['BUILD_SOURCEVERSION'];
if (!commit) {
console.warn('Skipping publish due to missing BUILD_SOURCEVERSION');
return;
}
const opts = minimist(process.argv.slice(2));
const [directory] = opts._;
const files = fileNames.map(fileName => join(directory, fileName));
publish(commit, files).catch(err => {
console.error(err);
process.exit(1);
});
}
if (process.argv.length < 3) {
console.error('Usage: node publish.js ');
process.exit(-1);
}
main();
================================================
FILE: build/azure-pipelines/common/publish.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as fs from 'fs';
import { Readable } from 'stream';
import * as crypto from 'crypto';
import * as azure from 'azure-storage';
import * as mime from 'mime';
import * as minimist from 'minimist';
import { DocumentClient, NewDocument } from 'documentdb';
if (process.argv.length < 6) {
console.error('Usage: node publish.js ');
process.exit(-1);
}
function hashStream(hashName: string, stream: Readable): Promise {
return new Promise((c, e) => {
const shasum = crypto.createHash(hashName);
stream
.on('data', shasum.update.bind(shasum))
.on('error', e)
.on('close', () => c(shasum.digest('hex')));
});
}
interface Config {
id: string;
frozen: boolean;
}
function createDefaultConfig(quality: string): Config {
return {
id: quality,
frozen: false
};
}
function getConfig(quality: string): Promise {
const client = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/config';
const query = {
query: `SELECT TOP 1 * FROM c WHERE c.id = @quality`,
parameters: [
{ name: '@quality', value: quality }
]
};
return new Promise((c, e) => {
client.queryDocuments(collection, query).toArray((err, results) => {
if (err && err.code !== 409) { return e(err); }
c(!results || results.length === 0 ? createDefaultConfig(quality) : results[0] as any as Config);
});
});
}
interface Asset {
platform: string;
type: string;
url: string;
mooncakeUrl?: string;
hash: string;
sha256hash: string;
size: number;
supportsFastUpdate?: boolean;
}
function createOrUpdate(commit: string, quality: string, platform: string, type: string, release: NewDocument, asset: Asset, isUpdate: boolean): Promise {
const client = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/' + quality;
const updateQuery = {
query: 'SELECT TOP 1 * FROM c WHERE c.id = @id',
parameters: [{ name: '@id', value: commit }]
};
let updateTries = 0;
function update(): Promise {
updateTries++;
return new Promise((c, e) => {
client.queryDocuments(collection, updateQuery).toArray((err, results) => {
if (err) { return e(err); }
if (results.length !== 1) { return e(new Error('No documents')); }
const release = results[0];
release.assets = [
...release.assets.filter((a: any) => !(a.platform === platform && a.type === type)),
asset
];
if (isUpdate) {
release.updates[platform] = type;
}
client.replaceDocument(release._self, release, err => {
if (err && err.code === 409 && updateTries < 5) { return c(update()); }
if (err) { return e(err); }
console.log('Build successfully updated.');
c();
});
});
});
}
return new Promise((c, e) => {
client.createDocument(collection, release, err => {
if (err && err.code === 409) { return c(update()); }
if (err) { return e(err); }
console.log('Build successfully published.');
c();
});
});
}
async function assertContainer(blobService: azure.BlobService, quality: string): Promise {
await new Promise((c, e) => blobService.createContainerIfNotExists(quality, { publicAccessLevel: 'blob' }, err => err ? e(err) : c()));
}
async function doesAssetExist(blobService: azure.BlobService, quality: string, blobName: string): Promise {
const existsResult = await new Promise((c, e) => blobService.doesBlobExist(quality, blobName, (err, r) => err ? e(err) : c(r)));
return existsResult.exists;
}
async function uploadBlob(blobService: azure.BlobService, quality: string, blobName: string, file: string): Promise {
const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
contentSettings: {
contentType: mime.lookup(file),
cacheControl: 'max-age=31536000, public'
}
};
await new Promise((c, e) => blobService.createBlockBlobFromLocalFile(quality, blobName, file, blobOptions, err => err ? e(err) : c()));
}
interface PublishOptions {
'upload-only': boolean;
}
async function publish(commit: string, quality: string, platform: string, type: string, name: string, version: string, _isUpdate: string, file: string, opts: PublishOptions): Promise {
const isUpdate = _isUpdate === 'true';
const queuedBy = process.env['BUILD_QUEUEDBY']!;
const sourceBranch = process.env['BUILD_SOURCEBRANCH']!;
console.log('Publishing...');
console.log('Quality:', quality);
console.log('Platform:', platform);
console.log('Type:', type);
console.log('Name:', name);
console.log('Version:', version);
console.log('Commit:', commit);
console.log('Is Update:', isUpdate);
console.log('File:', file);
const stat = await new Promise((c, e) => fs.stat(file, (err, stat) => err ? e(err) : c(stat)));
const size = stat.size;
console.log('Size:', size);
const stream = fs.createReadStream(file);
const [sha1hash, sha256hash] = await Promise.all([hashStream('sha1', stream), hashStream('sha256', stream)]);
console.log('SHA1:', sha1hash);
console.log('SHA256:', sha256hash);
const blobName = commit + '/' + name;
const storageAccount = process.env['AZURE_STORAGE_ACCOUNT_2']!;
const blobService = azure.createBlobService(storageAccount, process.env['AZURE_STORAGE_ACCESS_KEY_2']!)
.withFilter(new azure.ExponentialRetryPolicyFilter(20));
await assertContainer(blobService, quality);
const blobExists = await doesAssetExist(blobService, quality, blobName);
if (blobExists) {
console.log(`Blob ${quality}, ${blobName} already exists, not publishing again.`);
return;
}
console.log('Uploading blobs to Azure storage...');
await uploadBlob(blobService, quality, blobName, file);
console.log('Blobs successfully uploaded.');
const config = await getConfig(quality);
console.log('Quality config:', config);
const asset: Asset = {
platform: platform,
type: type,
url: `${process.env['AZURE_CDN_URL']}/${quality}/${blobName}`,
hash: sha1hash,
sha256hash,
size
};
// Remove this if we ever need to rollback fast updates for windows
if (/win32/.test(platform)) {
asset.supportsFastUpdate = true;
}
console.log('Asset:', JSON.stringify(asset, null, ' '));
const release = {
id: commit,
timestamp: (new Date()).getTime(),
version,
isReleased: false,
sourceBranch,
queuedBy,
assets: [] as Array,
updates: {} as any
};
if (!opts['upload-only']) {
release.assets.push(asset);
if (isUpdate) {
release.updates[platform] = type;
}
}
await createOrUpdate(commit, quality, platform, type, release, asset, isUpdate);
}
function main(): void {
const commit = process.env['BUILD_SOURCEVERSION'];
if (!commit) {
console.warn('Skipping publish due to missing BUILD_SOURCEVERSION');
return;
}
const opts = minimist(process.argv.slice(2), {
boolean: ['upload-only']
});
const [quality, platform, type, name, version, _isUpdate, file] = opts._;
publish(commit, quality, platform, type, name, version, _isUpdate, file, opts).catch(err => {
console.error(err);
process.exit(1);
});
}
main();
================================================
FILE: build/azure-pipelines/common/release.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { DocumentClient } from 'documentdb';
interface Config {
id: string;
frozen: boolean;
}
function createDefaultConfig(quality: string): Config {
return {
id: quality,
frozen: false
};
}
function getConfig(quality: string): Promise {
const client = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/config';
const query = {
query: `SELECT TOP 1 * FROM c WHERE c.id = @quality`,
parameters: [
{ name: '@quality', value: quality }
]
};
return new Promise((c, e) => {
client.queryDocuments(collection, query).toArray((err, results) => {
if (err && err.code !== 409) { return e(err); }
c(!results || results.length === 0 ? createDefaultConfig(quality) : results[0] as any as Config);
});
});
}
function doRelease(commit: string, quality: string): Promise {
const client = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/' + quality;
const query = {
query: 'SELECT TOP 1 * FROM c WHERE c.id = @id',
parameters: [{ name: '@id', value: commit }]
};
let updateTries = 0;
function update(): Promise {
updateTries++;
return new Promise((c, e) => {
client.queryDocuments(collection, query).toArray((err, results) => {
if (err) { return e(err); }
if (results.length !== 1) { return e(new Error('No documents')); }
const release = results[0];
release.isReleased = true;
client.replaceDocument(release._self, release, err => {
if (err && err.code === 409 && updateTries < 5) { return c(update()); }
if (err) { return e(err); }
console.log('Build successfully updated.');
c();
});
});
});
}
return update();
}
async function release(commit: string, quality: string): Promise {
const config = await getConfig(quality);
console.log('Quality config:', config);
if (config.frozen) {
console.log(`Skipping release because quality ${quality} is frozen.`);
return;
}
await doRelease(commit, quality);
}
function env(name: string): string {
const result = process.env[name];
if (!result) {
throw new Error(`Skipping release due to missing env: ${name}`);
}
return result;
}
async function main(): Promise {
const commit = env('BUILD_SOURCEVERSION');
const quality = env('VSCODE_QUALITY');
await release(commit, quality);
}
main().catch(err => {
console.error(err);
process.exit(1);
});
================================================
FILE: build/azure-pipelines/common/symbols.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as request from 'request';
import { createReadStream, createWriteStream, unlink, mkdir } from 'fs';
import * as github from 'github-releases';
import { join } from 'path';
import { tmpdir } from 'os';
import { promisify } from 'util';
const BASE_URL = 'https://rink.hockeyapp.net/api/2/';
const HOCKEY_APP_TOKEN_HEADER = 'X-HockeyAppToken';
export interface IVersions {
app_versions: IVersion[];
}
export interface IVersion {
id: number;
version: string;
}
export interface IApplicationAccessor {
accessToken: string;
appId: string;
}
export interface IVersionAccessor extends IApplicationAccessor {
id: string;
}
enum Platform {
WIN_32 = 'win32-ia32',
WIN_64 = 'win32-x64',
LINUX_64 = 'linux-x64',
MAC_OS = 'darwin-x64'
}
function symbolsZipName(platform: Platform, electronVersion: string, insiders: boolean): string {
return `${insiders ? 'insiders' : 'stable'}-symbols-v${electronVersion}-${platform}.zip`;
}
const SEED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
async function tmpFile(name: string): Promise {
let res = '';
for (let i = 0; i < 8; i++) {
res += SEED.charAt(Math.floor(Math.random() * SEED.length));
}
const tmpParent = join(tmpdir(), res);
await promisify(mkdir)(tmpParent);
return join(tmpParent, name);
}
function getVersions(accessor: IApplicationAccessor): Promise {
return asyncRequest({
url: `${BASE_URL}/apps/${accessor.appId}/app_versions`,
method: 'GET',
headers: {
[HOCKEY_APP_TOKEN_HEADER]: accessor.accessToken
}
});
}
function createVersion(accessor: IApplicationAccessor, version: string): Promise {
return asyncRequest({
url: `${BASE_URL}/apps/${accessor.appId}/app_versions/new`,
method: 'POST',
headers: {
[HOCKEY_APP_TOKEN_HEADER]: accessor.accessToken
},
formData: {
bundle_version: version
}
});
}
function updateVersion(accessor: IVersionAccessor, symbolsPath: string) {
return asyncRequest({
url: `${BASE_URL}/apps/${accessor.appId}/app_versions/${accessor.id}`,
method: 'PUT',
headers: {
[HOCKEY_APP_TOKEN_HEADER]: accessor.accessToken
},
formData: {
dsym: createReadStream(symbolsPath)
}
});
}
function asyncRequest(options: request.UrlOptions & request.CoreOptions): Promise {
return new Promise((resolve, reject) => {
request(options, (error, _response, body) => {
if (error) {
reject(error);
} else {
resolve(JSON.parse(body));
}
});
});
}
function downloadAsset(repository: any, assetName: string, targetPath: string, electronVersion: string) {
return new Promise((resolve, reject) => {
repository.getReleases({ tag_name: `v${electronVersion}` }, (err: any, releases: any) => {
if (err) {
reject(err);
} else {
const asset = releases[0].assets.filter((asset: any) => asset.name === assetName)[0];
if (!asset) {
reject(new Error(`Asset with name ${assetName} not found`));
} else {
repository.downloadAsset(asset, (err: any, reader: any) => {
if (err) {
reject(err);
} else {
const writer = createWriteStream(targetPath);
writer.on('error', reject);
writer.on('close', resolve);
reader.on('error', reject);
reader.pipe(writer);
}
});
}
}
});
});
}
interface IOptions {
repository: string;
platform: Platform;
versions: { code: string; insiders: boolean; electron: string; };
access: { hockeyAppToken: string; hockeyAppId: string; githubToken: string };
}
async function ensureVersionAndSymbols(options: IOptions) {
// Check version does not exist
console.log(`HockeyApp: checking for existing version ${options.versions.code} (${options.platform})`);
const versions = await getVersions({ accessToken: options.access.hockeyAppToken, appId: options.access.hockeyAppId });
if (!Array.isArray(versions.app_versions)) {
throw new Error(`Unexpected response: ${JSON.stringify(versions)}`);
}
if (versions.app_versions.some(v => v.version === options.versions.code)) {
console.log(`HockeyApp: Returning without uploading symbols because version ${options.versions.code} (${options.platform}) was already found`);
return;
}
// Download symbols for platform and electron version
const symbolsName = symbolsZipName(options.platform, options.versions.electron, options.versions.insiders);
const symbolsPath = await tmpFile('symbols.zip');
console.log(`HockeyApp: downloading symbols ${symbolsName} for electron ${options.versions.electron} (${options.platform}) into ${symbolsPath}`);
await downloadAsset(new (github as any)({ repo: options.repository, token: options.access.githubToken }), symbolsName, symbolsPath, options.versions.electron);
// Create version
console.log(`HockeyApp: creating new version ${options.versions.code} (${options.platform})`);
const version = await createVersion({ accessToken: options.access.hockeyAppToken, appId: options.access.hockeyAppId }, options.versions.code);
// Upload symbols
console.log(`HockeyApp: uploading symbols for version ${options.versions.code} (${options.platform})`);
await updateVersion({ id: String(version.id), accessToken: options.access.hockeyAppToken, appId: options.access.hockeyAppId }, symbolsPath);
// Cleanup
await promisify(unlink)(symbolsPath);
}
// Environment
const pakage = require('../../../package.json');
const product = require('../../../product.json');
const repository = product.electronRepository;
const electronVersion = require('../../lib/electron').getElectronVersion();
const insiders = product.quality !== 'stable';
let codeVersion = pakage.version;
if (insiders) {
codeVersion = `${codeVersion}-insider`;
}
const githubToken = process.argv[2];
const hockeyAppToken = process.argv[3];
const is64 = process.argv[4] === 'x64';
const hockeyAppId = process.argv[5];
if (process.argv.length !== 6) {
throw new Error(`HockeyApp: Unexpected number of arguments. Got ${process.argv}`);
}
let platform: Platform;
if (process.platform === 'darwin') {
platform = Platform.MAC_OS;
} else if (process.platform === 'win32') {
platform = is64 ? Platform.WIN_64 : Platform.WIN_32;
} else {
platform = Platform.LINUX_64;
}
// Create version and upload symbols in HockeyApp
if (repository && codeVersion && electronVersion && (product.quality === 'stable' || product.quality === 'insider')) {
ensureVersionAndSymbols({
repository,
platform,
versions: {
code: codeVersion,
insiders,
electron: electronVersion
},
access: {
githubToken,
hockeyAppToken,
hockeyAppId
}
}).then(() => {
console.log('HockeyApp: done');
}).catch(error => {
console.error(`HockeyApp: error ${error} (AppID: ${hockeyAppId})`);
return process.exit(1);
});
} else {
console.log(`HockeyApp: skipping due to unexpected context (repository: ${repository}, codeVersion: ${codeVersion}, electronVersion: ${electronVersion}, quality: ${product.quality})`);
}
================================================
FILE: build/azure-pipelines/common/sync-mooncake.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as url from 'url';
import * as azure from 'azure-storage';
import * as mime from 'mime';
import { DocumentClient, RetrievedDocument } from 'documentdb';
function log(...args: any[]) {
console.log(...[`[${new Date().toISOString()}]`, ...args]);
}
function error(...args: any[]) {
console.error(...[`[${new Date().toISOString()}]`, ...args]);
}
if (process.argv.length < 3) {
error('Usage: node sync-mooncake.js ');
process.exit(-1);
}
interface Build extends RetrievedDocument {
assets: Asset[];
}
interface Asset {
platform: string;
type: string;
url: string;
mooncakeUrl: string;
hash: string;
sha256hash: string;
size: number;
supportsFastUpdate?: boolean;
}
function updateBuild(commit: string, quality: string, platform: string, type: string, asset: Asset): Promise {
const client = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/' + quality;
const updateQuery = {
query: 'SELECT TOP 1 * FROM c WHERE c.id = @id',
parameters: [{ name: '@id', value: commit }]
};
let updateTries = 0;
function _update(): Promise {
updateTries++;
return new Promise((c, e) => {
client.queryDocuments(collection, updateQuery).toArray((err, results) => {
if (err) { return e(err); }
if (results.length !== 1) { return e(new Error('No documents')); }
const release = results[0];
release.assets = [
...release.assets.filter((a: any) => !(a.platform === platform && a.type === type)),
asset
];
client.replaceDocument(release._self, release, err => {
if (err && err.code === 409 && updateTries < 5) { return c(_update()); }
if (err) { return e(err); }
log('Build successfully updated.');
c();
});
});
});
}
return _update();
}
async function sync(commit: string, quality: string): Promise {
log(`Synchronizing Mooncake assets for ${quality}, ${commit}...`);
const cosmosdb = new DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT']!, { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = `dbs/builds/colls/${quality}`;
const query = {
query: 'SELECT TOP 1 * FROM c WHERE c.id = @id',
parameters: [{ name: '@id', value: commit }]
};
const build = await new Promise((c, e) => {
cosmosdb.queryDocuments(collection, query).toArray((err, results) => {
if (err) { return e(err); }
if (results.length !== 1) { return e(new Error('No documents')); }
c(results[0] as Build);
});
});
log(`Found build for ${commit}, with ${build.assets.length} assets`);
const storageAccount = process.env['AZURE_STORAGE_ACCOUNT_2']!;
const blobService = azure.createBlobService(storageAccount, process.env['AZURE_STORAGE_ACCESS_KEY_2']!)
.withFilter(new azure.ExponentialRetryPolicyFilter(20));
const mooncakeBlobService = azure.createBlobService(storageAccount, process.env['MOONCAKE_STORAGE_ACCESS_KEY']!, `${storageAccount}.blob.core.chinacloudapi.cn`)
.withFilter(new azure.ExponentialRetryPolicyFilter(20));
// mooncake is fussy and far away, this is needed!
blobService.defaultClientRequestTimeoutInMs = 10 * 60 * 1000;
mooncakeBlobService.defaultClientRequestTimeoutInMs = 10 * 60 * 1000;
for (const asset of build.assets) {
try {
const blobPath = url.parse(asset.url).path;
if (!blobPath) {
throw new Error(`Failed to parse URL: ${asset.url}`);
}
const blobName = blobPath.replace(/^\/\w+\//, '');
log(`Found ${blobName}`);
if (asset.mooncakeUrl) {
log(` Already in Mooncake ✔️`);
continue;
}
const readStream = blobService.createReadStream(quality, blobName, undefined!);
const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
contentSettings: {
contentType: mime.lookup(blobPath),
cacheControl: 'max-age=31536000, public'
}
};
const writeStream = mooncakeBlobService.createWriteStreamToBlockBlob(quality, blobName, blobOptions, undefined);
log(` Uploading to Mooncake...`);
await new Promise((c, e) => readStream.pipe(writeStream).on('finish', c).on('error', e));
log(` Updating build in DB...`);
asset.mooncakeUrl = `${process.env['MOONCAKE_CDN_URL']}${blobPath}`;
await updateBuild(commit, quality, asset.platform, asset.type, asset);
log(` Done ✔️`);
} catch (err) {
error(err);
}
}
log(`All done ✔️`);
}
function main(): void {
const commit = process.env['BUILD_SOURCEVERSION'];
if (!commit) {
error('Skipping publish due to missing BUILD_SOURCEVERSION');
return;
}
const quality = process.argv[2];
sync(commit, quality).catch(err => {
error(err);
process.exit(1);
});
}
main();
================================================
FILE: build/azure-pipelines/common/telemetry-config.json
================================================
[
{
"eventPrefix": "typescript-language-features/",
"sourceDirs": [
"../../s/extensions/typescript-language-features"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "git/",
"sourceDirs": [
"../../s/extensions/git"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "extension-telemetry/",
"sourceDirs": [
"vscode-extension-telemetry"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "vscode-markdown/",
"sourceDirs": [
"../../s/extensions/markdown-language-features"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "html-language-features/",
"sourceDirs": [
"../../s/extensions/html-language-features",
"vscode-html-languageservice"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "json-language-features/",
"sourceDirs": [
"../../s/extensions/json-language-features",
"vscode-json-languageservice"
],
"excludedDirs": [],
"applyEndpoints": true
},
{
"eventPrefix": "ms-vscode.node2/",
"sourceDirs": [
"vscode-chrome-debug-core",
"vscode-node-debug2"
],
"excludedDirs": [],
"applyEndpoints": true,
"patchDebugEvents": true
},
{
"eventPrefix": "ms-vscode.node/",
"sourceDirs": [
"vscode-chrome-debug-core",
"vscode-node-debug"
],
"excludedDirs": [],
"applyEndpoints": true,
"patchDebugEvents": true
}
]
================================================
FILE: build/azure-pipelines/darwin/continuous-build-darwin.yml
================================================
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- script: |
yarn --frozen-lockfile
displayName: Install Dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- script: |
yarn electron x64
displayName: Download Electron
- script: |
yarn gulp hygiene --skip-tslint
displayName: Run Hygiene Checks
- script: |
yarn gulp tslint
displayName: Run TSLint Checks
- script: |
yarn monaco-compile-check
displayName: Run Monaco Editor Checks
- script: |
yarn compile
displayName: Compile Sources
- script: |
yarn download-builtin-extensions
displayName: Download Built-in Extensions
- script: |
./scripts/test.sh --tfs "Unit Tests"
displayName: Run Unit Tests
- script: |
./scripts/test-integration.sh --tfs "Integration Tests"
displayName: Run Integration Tests
- task: PublishTestResults@2
displayName: Publish Tests Results
inputs:
testResultsFiles: '*-results.xml'
searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
condition: succeededOrFailed()
================================================
FILE: build/azure-pipelines/darwin/product-build-darwin.yml
================================================
steps:
- script: |
mkdir -p .build
echo -n $BUILD_SOURCEVERSION > .build/commit
echo -n $VSCODE_QUALITY > .build/quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- script: |
set -e
exit 1
displayName: Check RestoreCache
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
displayName: Prepare tooling
- script: |
set -e
git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
git fetch distro
git merge $(node -p "require('./package.json').distro")
displayName: Merge distro
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
- script: |
set -e
CHILD_CONCURRENCY=1 yarn --frozen-lockfile
displayName: Install dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- script: |
set -e
yarn postinstall
displayName: Run postinstall scripts
condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
- script: |
set -e
node build/azure-pipelines/mixin
displayName: Mix in quality
- script: |
set -e
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-darwin-min-ci
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-reh-darwin-min-ci
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-reh-web-darwin-min-ci
displayName: Build
- script: |
set -e
./scripts/test.sh --build --tfs "Unit Tests"
# APP_NAME="`ls $(agent.builddirectory)/VSCode-darwin | head -n 1`"
# yarn smoketest -- --build "$(agent.builddirectory)/VSCode-darwin/$APP_NAME"
displayName: Run unit tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
# Figure out the full absolute path of the product we just built
# including the remote server and configure the integration tests
# to run with these builds instead of running out of sources.
set -e
APP_ROOT=$(agent.builddirectory)/VSCode-darwin
APP_NAME="`ls $APP_ROOT | head -n 1`"
INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME/Contents/MacOS/Electron" \
VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-darwin" \
./scripts/test-integration.sh --build --tfs "Integration Tests"
displayName: Run integration tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
# Web Smoke Tests disabled due to https://github.com/microsoft/vscode/issues/80308
# - script: |
# set -e
# cd test/smoke
# yarn compile
# cd -
# yarn smoketest --web --headless
# continueOnError: true
# displayName: Run web smoke tests
# condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
set -e
pushd ../VSCode-darwin && zip -r -X -y ../VSCode-darwin.zip * && popd
displayName: Archive build
- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
inputs:
ConnectedServiceName: 'ESRP CodeSign'
FolderPath: '$(agent.builddirectory)'
Pattern: 'VSCode-darwin.zip'
signConfigType: inlineSignParams
inlineOperation: |
[
{
"keyCode": "CP-401337-Apple",
"operationSetCode": "MacAppDeveloperSign",
"parameters": [ ],
"toolName": "sign",
"toolVersion": "1.0"
}
]
SessionTimeout: 120
displayName: Codesign
- script: |
set -e
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
VSCODE_HOCKEYAPP_TOKEN="$(vscode-hockeyapp-token)" \
./build/azure-pipelines/darwin/publish.sh
displayName: Publish
- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
displayName: 'Component Detection'
continueOnError: true
================================================
FILE: build/azure-pipelines/darwin/publish.sh
================================================
#!/usr/bin/env bash
set -e
# remove pkg from archive
zip -d ../VSCode-darwin.zip "*.pkg"
# publish the build
PACKAGEJSON=`ls ../VSCode-darwin/*.app/Contents/Resources/app/package.json`
VERSION=`node -p "require(\"$PACKAGEJSON\").version"`
node build/azure-pipelines/common/publish.js \
"$VSCODE_QUALITY" \
darwin \
archive \
"VSCode-darwin-$VSCODE_QUALITY.zip" \
$VERSION \
true \
../VSCode-darwin.zip
# package Remote Extension Host
pushd .. && mv vscode-reh-darwin vscode-server-darwin && zip -Xry vscode-server-darwin.zip vscode-server-darwin && popd
# publish Remote Extension Host
node build/azure-pipelines/common/publish.js \
"$VSCODE_QUALITY" \
server-darwin \
archive-unsigned \
"vscode-server-darwin.zip" \
$VERSION \
true \
../vscode-server-darwin.zip
# publish hockeyapp symbols
node build/azure-pipelines/common/symbols.js "$VSCODE_MIXIN_PASSWORD" "$VSCODE_HOCKEYAPP_TOKEN" x64 "$VSCODE_HOCKEYAPP_ID_MACOS"
# upload configuration
yarn gulp upload-vscode-configuration
================================================
FILE: build/azure-pipelines/distro-build.yml
================================================
trigger:
branches:
include: ['master', 'release/*']
pr:
branches:
include: ['master', 'release/*']
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
git remote add distro "https://github.com/$VSCODE_MIXIN_REPO.git"
git fetch distro
# Push master branch into oss/master
git push distro origin/master:refs/heads/oss/master
# Push every release branch into oss/release
git for-each-ref --format="%(refname:short)" refs/remotes/origin/release/* | sed 's/^origin\/\(.*\)$/\0:refs\/heads\/oss\/\1/' | xargs git push distro
git merge $(node -p "require('./package.json').distro")
displayName: Sync & Merge Distro
================================================
FILE: build/azure-pipelines/exploration-build.yml
================================================
pool:
vmImage: 'Ubuntu-16.04'
trigger: none
pr: none
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
git checkout origin/electron-6.0.x
git merge origin/master
# Push master branch into exploration branch
git push origin HEAD:electron-6.0.x
displayName: Sync & Merge Exploration
================================================
FILE: build/azure-pipelines/linux/.gitignore
================================================
pat
================================================
FILE: build/azure-pipelines/linux/continuous-build-linux.yml
================================================
steps:
- script: |
set -e
sudo apt-get update
sudo apt-get install -y libxkbfile-dev pkg-config libsecret-1-dev libxss1 dbus xvfb libgtk-3-0
sudo cp build/azure-pipelines/linux/xvfb.init /etc/init.d/xvfb
sudo chmod +x /etc/init.d/xvfb
sudo update-rc.d xvfb defaults
sudo service xvfb start
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- script: |
yarn --frozen-lockfile
displayName: Install Dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- script: |
yarn electron x64
displayName: Download Electron
- script: |
yarn gulp hygiene --skip-tslint
displayName: Run Hygiene Checks
- script: |
yarn gulp tslint
displayName: Run TSLint Checks
- script: |
yarn monaco-compile-check
displayName: Run Monaco Editor Checks
- script: |
yarn compile
displayName: Compile Sources
- script: |
yarn download-builtin-extensions
displayName: Download Built-in Extensions
- script: |
DISPLAY=:10 ./scripts/test.sh --tfs "Unit Tests"
displayName: Run Unit Tests
- script: |
DISPLAY=:10 ./scripts/test-integration.sh --tfs "Integration Tests"
displayName: Run Integration Tests
- task: PublishTestResults@2
displayName: Publish Tests Results
inputs:
testResultsFiles: '*-results.xml'
searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
condition: succeededOrFailed()
================================================
FILE: build/azure-pipelines/linux/frozen-check.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const documentdb_1 = require("documentdb");
function createDefaultConfig(quality) {
return {
id: quality,
frozen: false
};
}
function getConfig(quality) {
const client = new documentdb_1.DocumentClient(process.env['AZURE_DOCUMENTDB_ENDPOINT'], { masterKey: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
const collection = 'dbs/builds/colls/config';
const query = {
query: `SELECT TOP 1 * FROM c WHERE c.id = @quality`,
parameters: [
{ name: '@quality', value: quality }
]
};
return new Promise((c, e) => {
client.queryDocuments(collection, query).toArray((err, results) => {
if (err && err.code !== 409) {
return e(err);
}
c(!results || results.length === 0 ? createDefaultConfig(quality) : results[0]);
});
});
}
getConfig(process.argv[2])
.then(config => {
console.log(config.frozen);
process.exit(0);
})
.catch(err => {
console.error(err);
process.exit(1);
});
================================================
FILE: build/azure-pipelines/linux/multiarch/alpine/build.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/alpine/prebuild.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/alpine/publish.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/arm64/build.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/arm64/prebuild.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/arm64/publish.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/armhf/build.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/armhf/prebuild.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/multiarch/armhf/publish.sh
================================================
#!/usr/bin/env bash
set -e
echo 'noop'
================================================
FILE: build/azure-pipelines/linux/product-build-linux-multiarch.yml
================================================
steps:
- script: |
mkdir -p .build
echo -n $BUILD_SOURCEVERSION > .build/commit
echo -n $VSCODE_QUALITY > .build/quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- script: |
set -e
exit 1
displayName: Check RestoreCache
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- task: Docker@1
displayName: 'Pull image'
inputs:
azureSubscriptionEndpoint: 'vscode-builds-subscription'
azureContainerRegistry: vscodehub.azurecr.io
command: 'Run an image'
imageName: 'vscode-linux-build-agent:$(VSCODE_ARCH)'
containerCommand: uname
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
displayName: Prepare tooling
- script: |
set -e
git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
git fetch distro
git merge $(node -p "require('./package.json').distro")
displayName: Merge distro
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
- script: |
set -e
CHILD_CONCURRENCY=1 yarn --frozen-lockfile
displayName: Install dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- script: |
set -e
yarn postinstall
displayName: Run postinstall scripts
condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
- script: |
set -e
node build/azure-pipelines/mixin
displayName: Mix in quality
- script: |
set -e
CHILD_CONCURRENCY=1 ./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/prebuild.sh
displayName: Prebuild
- script: |
set -e
./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/build.sh
displayName: Build
- script: |
set -e
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
VSCODE_HOCKEYAPP_TOKEN="$(vscode-hockeyapp-token)" \
./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/publish.sh
displayName: Publish
- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
displayName: 'Component Detection'
continueOnError: true
================================================
FILE: build/azure-pipelines/linux/product-build-linux.yml
================================================
steps:
- script: |
mkdir -p .build
echo -n $BUILD_SOURCEVERSION > .build/commit
echo -n $VSCODE_QUALITY > .build/quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- script: |
set -e
exit 1
displayName: Check RestoreCache
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
displayName: Prepare tooling
- script: |
set -e
git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
git fetch distro
git merge $(node -p "require('./package.json').distro")
displayName: Merge distro
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
- script: |
set -e
CHILD_CONCURRENCY=1 yarn --frozen-lockfile
displayName: Install dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- script: |
set -e
yarn postinstall
displayName: Run postinstall scripts
condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
- script: |
set -e
node build/azure-pipelines/mixin
displayName: Mix in quality
- script: |
set -e
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-linux-x64-min-ci
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-reh-linux-x64-min-ci
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-reh-web-linux-x64-min-ci
displayName: Build
- script: |
set -e
service xvfb start
displayName: Start xvfb
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
set -e
DISPLAY=:10 ./scripts/test.sh --build --tfs "Unit Tests"
displayName: Run unit tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
# Figure out the full absolute path of the product we just built
# including the remote server and configure the integration tests
# to run with these builds instead of running out of sources.
set -e
APP_ROOT=$(agent.builddirectory)/VSCode-linux-x64
APP_NAME=$(node -p "require(\"$APP_ROOT/resources/app/product.json\").applicationName")
INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME" \
VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-linux-x64" \
DISPLAY=:10 ./scripts/test-integration.sh --build --tfs "Integration Tests"
# yarn smoketest -- --build "$(agent.builddirectory)/VSCode-linux-x64"
displayName: Run integration tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
set -e
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
VSCODE_HOCKEYAPP_TOKEN="$(vscode-hockeyapp-token)" \
./build/azure-pipelines/linux/publish.sh
displayName: Publish
- task: PublishPipelineArtifact@0
displayName: 'Publish Pipeline Artifact'
inputs:
artifactName: snap-x64
targetPath: .build/linux/snap-tarball
- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
displayName: 'Component Detection'
continueOnError: true
================================================
FILE: build/azure-pipelines/linux/publish.sh
================================================
#!/usr/bin/env bash
set -e
REPO="$(pwd)"
ROOT="$REPO/.."
# Publish tarball
PLATFORM_LINUX="linux-x64"
BUILDNAME="VSCode-$PLATFORM_LINUX"
BUILD="$ROOT/$BUILDNAME"
BUILD_VERSION="$(date +%s)"
[ -z "$VSCODE_QUALITY" ] && TARBALL_FILENAME="code-$BUILD_VERSION.tar.gz" || TARBALL_FILENAME="code-$VSCODE_QUALITY-$BUILD_VERSION.tar.gz"
TARBALL_PATH="$ROOT/$TARBALL_FILENAME"
PACKAGEJSON="$BUILD/resources/app/package.json"
VERSION=$(node -p "require(\"$PACKAGEJSON\").version")
rm -rf $ROOT/code-*.tar.*
(cd $ROOT && tar -czf $TARBALL_PATH $BUILDNAME)
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "$PLATFORM_LINUX" archive-unsigned "$TARBALL_FILENAME" "$VERSION" true "$TARBALL_PATH"
# Publish Remote Extension Host
LEGACY_SERVER_BUILD_NAME="vscode-reh-$PLATFORM_LINUX"
SERVER_BUILD_NAME="vscode-server-$PLATFORM_LINUX"
SERVER_TARBALL_FILENAME="vscode-server-$PLATFORM_LINUX.tar.gz"
SERVER_TARBALL_PATH="$ROOT/$SERVER_TARBALL_FILENAME"
rm -rf $ROOT/vscode-server-*.tar.*
(cd $ROOT && mv $LEGACY_SERVER_BUILD_NAME $SERVER_BUILD_NAME && tar --owner=0 --group=0 -czf $SERVER_TARBALL_PATH $SERVER_BUILD_NAME)
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "server-$PLATFORM_LINUX" archive-unsigned "$SERVER_TARBALL_FILENAME" "$VERSION" true "$SERVER_TARBALL_PATH"
# Publish hockeyapp symbols
node build/azure-pipelines/common/symbols.js "$VSCODE_MIXIN_PASSWORD" "$VSCODE_HOCKEYAPP_TOKEN" "x64" "$VSCODE_HOCKEYAPP_ID_LINUX64"
# Publish DEB
yarn gulp "vscode-linux-x64-build-deb"
PLATFORM_DEB="linux-deb-x64"
DEB_ARCH="amd64"
DEB_FILENAME="$(ls $REPO/.build/linux/deb/$DEB_ARCH/deb/)"
DEB_PATH="$REPO/.build/linux/deb/$DEB_ARCH/deb/$DEB_FILENAME"
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "$PLATFORM_DEB" package "$DEB_FILENAME" "$VERSION" true "$DEB_PATH"
# Publish RPM
yarn gulp "vscode-linux-x64-build-rpm"
PLATFORM_RPM="linux-rpm-x64"
RPM_ARCH="x86_64"
RPM_FILENAME="$(ls $REPO/.build/linux/rpm/$RPM_ARCH/ | grep .rpm)"
RPM_PATH="$REPO/.build/linux/rpm/$RPM_ARCH/$RPM_FILENAME"
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "$PLATFORM_RPM" package "$RPM_FILENAME" "$VERSION" true "$RPM_PATH"
# Publish Snap
yarn gulp "vscode-linux-x64-prepare-snap"
# Pack snap tarball artifact, in order to preserve file perms
mkdir -p $REPO/.build/linux/snap-tarball
SNAP_TARBALL_PATH="$REPO/.build/linux/snap-tarball/snap-x64.tar.gz"
rm -rf $SNAP_TARBALL_PATH
(cd .build/linux && tar -czf $SNAP_TARBALL_PATH snap)
================================================
FILE: build/azure-pipelines/linux/snap-build-linux.yml
================================================
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- task: DownloadPipelineArtifact@0
displayName: 'Download Pipeline Artifact'
inputs:
artifactName: snap-x64
targetPath: .build/linux/snap-tarball
- script: |
set -e
# Get snapcraft version
snapcraft --version
# Make sure we get latest packages
sudo apt-get update
sudo apt-get upgrade -y
# Define variables
REPO="$(pwd)"
SNAP_ROOT="$REPO/.build/linux/snap/x64"
# Install build dependencies
(cd build && yarn)
# Unpack snap tarball artifact, in order to preserve file perms
SNAP_TARBALL_PATH="$REPO/.build/linux/snap-tarball/snap-x64.tar.gz"
(cd .build/linux && tar -xzf $SNAP_TARBALL_PATH)
# Create snap package
BUILD_VERSION="$(date +%s)"
SNAP_FILENAME="code-$VSCODE_QUALITY-$BUILD_VERSION.snap"
PACKAGEJSON="$(ls $SNAP_ROOT/code*/usr/share/code*/resources/app/package.json)"
VERSION=$(node -p "require(\"$PACKAGEJSON\").version")
SNAP_PATH="$SNAP_ROOT/$SNAP_FILENAME"
(cd $SNAP_ROOT/code-* && sudo --preserve-env snapcraft snap --output "$SNAP_PATH")
# Publish snap package
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "linux-snap-x64" package "$SNAP_FILENAME" "$VERSION" true "$SNAP_PATH"
================================================
FILE: build/azure-pipelines/linux/xvfb.init
================================================
#!/bin/bash
#
# /etc/rc.d/init.d/xvfbd
#
# chkconfig: 345 95 28
# description: Starts/Stops X Virtual Framebuffer server
# processname: Xvfb
#
### BEGIN INIT INFO
# Provides: xvfb
# Required-Start: $remote_fs $syslog
# Required-Stop: $remote_fs $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start xvfb at boot time
# Description: Enable xvfb provided by daemon.
### END INIT INFO
[ "${NETWORKING}" = "no" ] && exit 0
PROG="/usr/bin/Xvfb"
PROG_OPTIONS=":10 -ac"
PROG_OUTPUT="/tmp/Xvfb.out"
case "$1" in
start)
echo "Starting : X Virtual Frame Buffer "
$PROG $PROG_OPTIONS>>$PROG_OUTPUT 2>&1 &
disown -ar
;;
stop)
echo "Shutting down : X Virtual Frame Buffer"
killproc $PROG
RETVAL=$?
[ $RETVAL -eq 0 ] && /bin/rm -f /var/lock/subsys/Xvfb
/var/run/Xvfb.pid
echo
;;
restart|reload)
$0 stop
$0 start
RETVAL=$?
;;
status)
status Xvfb
RETVAL=$?
;;
*)
echo $"Usage: $0 (start|stop|restart|reload|status)"
exit 1
esac
exit $RETVAL
================================================
FILE: build/azure-pipelines/mixin.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const json = require('gulp-json-editor');
const buffer = require('gulp-buffer');
const filter = require('gulp-filter');
const es = require('event-stream');
const vfs = require('vinyl-fs');
const fancyLog = require('fancy-log');
const ansiColors = require('ansi-colors');
function main() {
const quality = process.env['VSCODE_QUALITY'];
if (!quality) {
console.log('Missing VSCODE_QUALITY, skipping mixin');
return;
}
const productJsonFilter = filter('product.json', { restore: true });
fancyLog(ansiColors.blue('[mixin]'), `Mixing in sources:`);
return vfs
.src(`quality/${quality}/**`, { base: `quality/${quality}` })
.pipe(filter(f => !f.isDirectory()))
.pipe(productJsonFilter)
.pipe(buffer())
.pipe(json(o => Object.assign({}, require('../product.json'), o)))
.pipe(productJsonFilter.restore)
.pipe(es.mapSync(function (f) {
fancyLog(ansiColors.blue('[mixin]'), f.relative, ansiColors.green('✔︎'));
return f;
}))
.pipe(vfs.dest('.'));
}
main();
================================================
FILE: build/azure-pipelines/product-build.yml
================================================
resources:
containers:
- container: vscode-x64
image: vscodehub.azurecr.io/vscode-linux-build-agent:x64
endpoint: VSCodeHub
- container: snapcraft
image: snapcore/snapcraft:stable
jobs:
- job: Compile
pool:
vmImage: 'Ubuntu-16.04'
container: vscode-x64
steps:
- template: product-compile.yml
- job: Windows
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_WIN32'], 'true'))
pool:
vmImage: VS2017-Win2016
variables:
VSCODE_ARCH: x64
dependsOn:
- Compile
steps:
- template: win32/product-build-win32.yml
- job: Windows32
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_WIN32_32BIT'], 'true'))
pool:
vmImage: VS2017-Win2016
variables:
VSCODE_ARCH: ia32
dependsOn:
- Compile
steps:
- template: win32/product-build-win32.yml
- job: Linux
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_LINUX'], 'true'))
pool:
vmImage: 'Ubuntu-16.04'
container: vscode-x64
dependsOn:
- Compile
steps:
- template: linux/product-build-linux.yml
- job: LinuxSnap
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_LINUX'], 'true'))
pool:
vmImage: 'Ubuntu-16.04'
container: snapcraft
dependsOn: Linux
steps:
- template: linux/snap-build-linux.yml
- job: LinuxArmhf
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_LINUX_ARMHF'], 'true'))
pool:
vmImage: 'Ubuntu-16.04'
variables:
VSCODE_ARCH: armhf
dependsOn:
- Compile
steps:
- template: linux/product-build-linux-multiarch.yml
- job: LinuxArm64
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_LINUX_ARM64'], 'true'), ne(variables['VSCODE_QUALITY'], 'stable'))
pool:
vmImage: 'Ubuntu-16.04'
variables:
VSCODE_ARCH: arm64
dependsOn:
- Compile
steps:
- template: linux/product-build-linux-multiarch.yml
- job: LinuxAlpine
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_LINUX_ALPINE'], 'true'))
pool:
vmImage: 'Ubuntu-16.04'
variables:
VSCODE_ARCH: alpine
dependsOn:
- Compile
steps:
- template: linux/product-build-linux-multiarch.yml
- job: LinuxWeb
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_WEB'], 'true'))
pool:
vmImage: 'Ubuntu-16.04'
variables:
VSCODE_ARCH: x64
dependsOn:
- Compile
steps:
- template: web/product-build-web.yml
- job: macOS
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), eq(variables['VSCODE_BUILD_MACOS'], 'true'))
pool:
vmImage: macOS 10.13
dependsOn:
- Compile
steps:
- template: darwin/product-build-darwin.yml
- job: Release
condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), or(eq(variables['VSCODE_RELEASE'], 'true'), and(or(eq(variables['VSCODE_QUALITY'], 'insider'), eq(variables['VSCODE_QUALITY'], 'exploration')), eq(variables['Build.Reason'], 'Schedule'))))
pool:
vmImage: 'Ubuntu-16.04'
dependsOn:
- Windows
- Windows32
- Linux
- LinuxSnap
- LinuxArmhf
- LinuxAlpine
- macOS
steps:
- template: release.yml
- job: Mooncake
pool:
vmImage: 'Ubuntu-16.04'
condition: and(succeededOrFailed(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'))
dependsOn:
- Windows
- Windows32
- Linux
- LinuxSnap
- LinuxArmhf
- LinuxAlpine
- LinuxWeb
- macOS
steps:
- template: sync-mooncake.yml
trigger: none
pr: none
schedules:
- cron: "0 5 * * Mon-Fri"
displayName: Mon-Fri at 7:00
branches:
include:
- master
================================================
FILE: build/azure-pipelines/product-compile.yml
================================================
steps:
- script: |
mkdir -p .build
echo -n $BUILD_SOURCEVERSION > .build/commit
echo -n $VSCODE_QUALITY > .build/quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
displayName: Prepare tooling
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
git fetch distro
git merge $(node -p "require('./package.json').distro")
displayName: Merge distro
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
CHILD_CONCURRENCY=1 yarn --frozen-lockfile
displayName: Install dependencies
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'), ne(variables['CacheRestored'], 'true'))
- script: |
set -e
yarn postinstall
displayName: Run postinstall scripts
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'), eq(variables['CacheRestored'], 'true'))
# Mixin must run before optimize, because the CSS loader will
# inline small SVGs
- script: |
set -e
node build/azure-pipelines/mixin
displayName: Mix in quality
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
yarn gulp hygiene --skip-tslint
yarn gulp tslint
yarn monaco-compile-check
displayName: Run hygiene, tslint and monaco compile checks
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- script: |
set -
./build/azure-pipelines/common/extract-telemetry.sh
displayName: Extract Telemetry
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
AZURE_WEBVIEW_STORAGE_ACCESS_KEY="$(vscode-webview-storage-key)" \
./build/azure-pipelines/common/publish-webview.sh
displayName: Publish Webview
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
yarn gulp compile-build
yarn gulp compile-extensions-build
yarn gulp minify-vscode
yarn gulp minify-vscode-reh
yarn gulp minify-vscode-reh-web
displayName: Compile
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- script: |
set -e
AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
node build/azure-pipelines/upload-sourcemaps
displayName: Upload sourcemaps
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
================================================
FILE: build/azure-pipelines/publish-types/.gitignore
================================================
node_modules/
*.js
================================================
FILE: build/azure-pipelines/publish-types/check-version.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as cp from 'child_process';
let tag = '';
try {
tag = cp
.execSync('git describe --tags `git rev-list --tags --max-count=1`')
.toString()
.trim();
if (!isValidTag(tag)) {
throw Error(`Invalid tag ${tag}`);
}
} catch (err) {
console.error(err);
console.error('Failed to update types');
process.exit(1);
}
function isValidTag(t: string) {
if (t.split('.').length !== 3) {
return false;
}
const [major, minor, bug] = t.split('.');
// Only release for tags like 1.34.0
if (bug !== '0') {
return false;
}
if (parseInt(major, 10) === NaN || parseInt(minor, 10) === NaN) {
return false;
}
return true;
}
================================================
FILE: build/azure-pipelines/publish-types/publish-types.yml
================================================
# Publish @types/vscode for each release
trigger:
branches:
include: ['refs/tags/*']
pr: none
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- bash: |
TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
CHANNEL="G1C14HJ2F"
if [ "$TAG_VERSION" == "1.999.0" ]; then
MESSAGE=". Someone pushed 1.999.0 tag. Please delete it ASAP from remote and local."
curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
-H 'Content-type: application/json; charset=utf-8' \
--data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE"'"}' \
https://slack.com/api/chat.postMessage
exit 1
fi
displayName: Check 1.999.0 tag
- bash: |
# Install build dependencies
(cd build && yarn)
node build/azure-pipelines/publish-types/check-version.js
displayName: Check version
- bash: |
git config --global user.email "vscode@microsoft.com"
git config --global user.name "VSCode"
git clone https://$(GITHUB_TOKEN)@github.com/DefinitelyTyped/DefinitelyTyped.git --depth=1
node build/azure-pipelines/publish-types/update-types.js
TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
cd DefinitelyTyped
git diff --color | cat
git add -A
git status
git checkout -b "vscode-types-$TAG_VERSION"
git commit -m "VS Code $TAG_VERSION Extension API"
git push origin "vscode-types-$TAG_VERSION"
displayName: Push update to DefinitelyTyped
- bash: |
TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
CHANNEL="G1C14HJ2F"
MESSAGE="DefinitelyTyped/DefinitelyTyped#vscode-types-$TAG_VERSION created. Endgame master, please open this link, examine changes and create a PR:"
LINK="https://github.com/DefinitelyTyped/DefinitelyTyped/compare/vscode-types-$TAG_VERSION?quick_pull=1&body=Updating%20VS%20Code%20Extension%20API.%20See%20https%3A%2F%2Fgithub.com%2Fmicrosoft%2Fvscode%2Fissues%2F70175%20for%20details."
MESSAGE2="[@octref, @jrieken, @kmaetzel, @egamma]. Please review and merge PR to publish @types/vscode."
curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
-H 'Content-type: application/json; charset=utf-8' \
--data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE"'"}' \
https://slack.com/api/chat.postMessage
curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
-H 'Content-type: application/json; charset=utf-8' \
--data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$LINK"'"}' \
https://slack.com/api/chat.postMessage
curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
-H 'Content-type: application/json; charset=utf-8' \
--data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE2"'"}' \
https://slack.com/api/chat.postMessage
displayName: Send message on Slack
================================================
FILE: build/azure-pipelines/publish-types/update-types.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as fs from 'fs';
import * as cp from 'child_process';
import * as path from 'path';
let tag = '';
try {
tag = cp
.execSync('git describe --tags `git rev-list --tags --max-count=1`')
.toString()
.trim();
const dtsUri = `https://raw.githubusercontent.com/microsoft/vscode/${tag}/src/vs/vscode.d.ts`;
const outPath = path.resolve(process.cwd(), 'DefinitelyTyped/types/vscode/index.d.ts');
cp.execSync(`curl ${dtsUri} --output ${outPath}`);
updateDTSFile(outPath, tag);
console.log(`Done updating vscode.d.ts at ${outPath}`);
} catch (err) {
console.error(err);
console.error('Failed to update types');
process.exit(1);
}
function updateDTSFile(outPath: string, tag: string) {
const oldContent = fs.readFileSync(outPath, 'utf-8');
const newContent = getNewFileContent(oldContent, tag);
fs.writeFileSync(outPath, newContent);
}
function getNewFileContent(content: string, tag: string) {
const oldheader = [
`/*---------------------------------------------------------------------------------------------`,
` * Copyright (c) Microsoft Corporation. All rights reserved.`,
` * Licensed under the MIT License. See License.txt in the project root for license information.`,
` *--------------------------------------------------------------------------------------------*/`
].join('\n');
return getNewFileHeader(tag) + content.slice(oldheader.length);
}
function getNewFileHeader(tag: string) {
const [major, minor] = tag.split('.');
const shorttag = `${major}.${minor}`;
const header = [
`// Type definitions for Visual Studio Code ${shorttag}`,
`// Project: https://github.com/microsoft/vscode`,
`// Definitions by: Visual Studio Code Team, Microsoft `,
`// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped`,
``,
`/*---------------------------------------------------------------------------------------------`,
` * Copyright (c) Microsoft Corporation. All rights reserved.`,
` * Licensed under the MIT License.`,
` * See https://github.com/Microsoft/vscode/blob/master/LICENSE.txt for license information.`,
` *--------------------------------------------------------------------------------------------*/`,
``,
`/**`,
` * Type Definition for Visual Studio Code ${shorttag} Extension API`,
` * See https://code.visualstudio.com/api for more information`,
` */`
].join('\n');
return header;
}
================================================
FILE: build/azure-pipelines/release.yml
================================================
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.x"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
(cd build ; yarn)
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
node build/azure-pipelines/common/release.js
================================================
FILE: build/azure-pipelines/sync-mooncake.yml
================================================
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
(cd build ; yarn)
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
MOONCAKE_STORAGE_ACCESS_KEY="$(vscode-mooncake-storage-key)" \
node build/azure-pipelines/common/sync-mooncake.js "$VSCODE_QUALITY"
================================================
FILE: build/azure-pipelines/upload-sourcemaps.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const path = require('path');
const es = require('event-stream');
const azure = require('gulp-azure-storage');
const vfs = require('vinyl-fs');
const util = require('../lib/util');
const root = path.dirname(path.dirname(__dirname));
const commit = util.getVersion(root);
// optionally allow to pass in explicit base/maps to upload
const [, , base, maps] = process.argv;
const fetch = function (base, maps = `${base}/**/*.map`) {
return vfs.src(maps, { base })
.pipe(es.mapSync(f => {
f.path = `${f.base}/core/${f.relative}`;
return f;
}));
};
function main() {
const sources = [];
// vscode client maps (default)
if (!base) {
const vs = fetch('out-vscode-min'); // client source-maps only
sources.push(vs);
const extensionsOut = vfs.src(['.build/extensions/**/*.js.map', '!**/node_modules/**'], { base: '.build' });
sources.push(extensionsOut);
}
// specific client base/maps
else {
sources.push(fetch(base, maps));
}
return es.merge(...sources)
.pipe(es.through(function (data) {
console.log('Uploading Sourcemap', data.relative); // debug
this.emit('data', data);
}))
.pipe(azure.upload({
account: process.env.AZURE_STORAGE_ACCOUNT,
key: process.env.AZURE_STORAGE_ACCESS_KEY,
container: 'sourcemaps',
prefix: commit + '/'
}));
}
main();
================================================
FILE: build/azure-pipelines/web/product-build-web.yml
================================================
steps:
- script: |
mkdir -p .build
echo -n $BUILD_SOURCEVERSION > .build/commit
echo -n $VSCODE_QUALITY > .build/quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- script: |
set -e
exit 1
displayName: Check RestoreCache
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- script: |
set -e
cat << EOF > ~/.netrc
machine github.com
login vscode
password $(github-distro-mixin-password)
EOF
git config user.email "vscode@microsoft.com"
git config user.name "VSCode"
displayName: Prepare tooling
- script: |
set -e
git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
git fetch distro
git merge $(node -p "require('./package.json').distro")
displayName: Merge distro
# - task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
# inputs:
# keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
# targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
# vstsFeed: 'npm-vscode'
- script: |
set -e
CHILD_CONCURRENCY=1 yarn --frozen-lockfile
displayName: Install dependencies
# condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
# - task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
# inputs:
# keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
# targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
# vstsFeed: 'npm-vscode'
# condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
# - script: |
# set -e
# yarn postinstall
# displayName: Run postinstall scripts
# condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
- script: |
set -e
node build/azure-pipelines/mixin
displayName: Mix in quality
- script: |
set -e
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
yarn gulp vscode-web-min-ci
displayName: Build
# upload only the workbench.web.api.js source maps because
# we just compiled these bits in the previous step and the
# general task to upload source maps has already been run
- script: |
set -e
AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
node build/azure-pipelines/upload-sourcemaps out-vscode-web-min out-vscode-web-min/vs/workbench/workbench.web.api.js.map
displayName: Upload sourcemaps (Web)
- script: |
set -e
AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
./build/azure-pipelines/web/publish.sh
displayName: Publish
================================================
FILE: build/azure-pipelines/web/publish.sh
================================================
#!/usr/bin/env bash
set -e
REPO="$(pwd)"
ROOT="$REPO/.."
# Publish Web Client
WEB_BUILD_NAME="vscode-web"
WEB_TARBALL_FILENAME="vscode-web.tar.gz"
WEB_TARBALL_PATH="$ROOT/$WEB_TARBALL_FILENAME"
BUILD="$ROOT/$WEB_BUILD_NAME"
PACKAGEJSON="$BUILD/package.json"
VERSION=$(node -p "require(\"$PACKAGEJSON\").version")
rm -rf $ROOT/vscode-web.tar.*
(cd $ROOT && tar --owner=0 --group=0 -czf $WEB_TARBALL_PATH $WEB_BUILD_NAME)
node build/azure-pipelines/common/publish.js "$VSCODE_QUALITY" "web-standalone" archive-unsigned "$WEB_TARBALL_FILENAME" "$VERSION" true "$WEB_TARBALL_PATH"
================================================
FILE: build/azure-pipelines/win32/ESRPClient/NuGet.config
================================================
================================================
FILE: build/azure-pipelines/win32/ESRPClient/packages.config
================================================
================================================
FILE: build/azure-pipelines/win32/continuous-build-win32.yml
================================================
steps:
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: UsePythonVersion@0
inputs:
versionSpec: '2.x'
addToPath: true
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
- powershell: |
yarn --frozen-lockfile
displayName: Install Dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: '$(ArtifactFeed)'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- powershell: |
yarn electron
- script: |
yarn gulp hygiene --skip-tslint
displayName: Run Hygiene Checks
- script: |
yarn gulp tslint
displayName: Run TSLint Checks
- powershell: |
yarn monaco-compile-check
displayName: Run Monaco Editor Checks
- powershell: |
yarn compile
displayName: Compile Sources
- powershell: |
yarn download-builtin-extensions
displayName: Download Built-in Extensions
- powershell: |
.\scripts\test.bat --tfs "Unit Tests"
displayName: Run Unit Tests
- powershell: |
.\scripts\test-integration.bat --tfs "Integration Tests"
displayName: Run Integration Tests
- task: PublishTestResults@2
displayName: Publish Tests Results
inputs:
testResultsFiles: '*-results.xml'
searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
condition: succeededOrFailed()
================================================
FILE: build/azure-pipelines/win32/exec.ps1
================================================
# Taken from psake https://github.com/psake/psake
<#
.SYNOPSIS
This is a helper function that runs a scriptblock and checks the PS variable $lastexitcode
to see if an error occcured. If an error is detected then an exception is thrown.
This function allows you to run command-line programs without having to
explicitly check the $lastexitcode variable.
.EXAMPLE
exec { svn info $repository_trunk } "Error executing SVN. Please verify SVN command-line client is installed"
#>
function Exec
{
[CmdletBinding()]
param(
[Parameter(Position=0,Mandatory=1)][scriptblock]$cmd,
[Parameter(Position=1,Mandatory=0)][string]$errorMessage = ($msgs.error_bad_command -f $cmd)
)
& $cmd
if ($lastexitcode -ne 0) {
throw ("Exec: " + $errorMessage)
}
}
================================================
FILE: build/azure-pipelines/win32/import-esrp-auth-cert.ps1
================================================
Param(
[string]$AuthCertificateBase64,
[string]$AuthCertificateKey
)
# Import auth certificate
$AuthCertificateFileName = [System.IO.Path]::GetTempFileName()
$AuthCertificateBytes = [Convert]::FromBase64String($AuthCertificateBase64)
[IO.File]::WriteAllBytes($AuthCertificateFileName, $AuthCertificateBytes)
$AuthCertificate = Import-PfxCertificate -FilePath $AuthCertificateFileName -CertStoreLocation Cert:\LocalMachine\My -Password (ConvertTo-SecureString $AuthCertificateKey -AsPlainText -Force)
rm $AuthCertificateFileName
$ESRPAuthCertificateSubjectName = $AuthCertificate.Subject
Write-Output ("##vso[task.setvariable variable=ESRPAuthCertificateSubjectName;]$ESRPAuthCertificateSubjectName")
================================================
FILE: build/azure-pipelines/win32/product-build-win32.yml
================================================
steps:
- powershell: |
mkdir .build -ea 0
"$env:BUILD_SOURCEVERSION" | Out-File -Encoding ascii -NoNewLine .build\commit
"$env:VSCODE_QUALITY" | Out-File -Encoding ascii -NoNewLine .build\quality
displayName: Prepare cache flag
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/commit, .build/quality'
targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
vstsFeed: 'npm-vscode'
platformIndependent: true
alias: 'Compilation'
- powershell: |
$ErrorActionPreference = "Stop"
exit 1
displayName: Check RestoreCache
condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
- task: NodeTool@0
inputs:
versionSpec: "10.15.1"
- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
inputs:
versionSpec: "1.x"
- task: UsePythonVersion@0
inputs:
versionSpec: '2.x'
addToPath: true
- task: AzureKeyVault@1
displayName: 'Azure Key Vault: Get Secrets'
inputs:
azureSubscription: 'vscode-builds-subscription'
KeyVaultName: vscode
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
"machine github.com`nlogin vscode`npassword $(github-distro-mixin-password)" | Out-File "$env:USERPROFILE\_netrc" -Encoding ASCII
exec { git config user.email "vscode@microsoft.com" }
exec { git config user.name "VSCode" }
mkdir .build -ea 0
"$(VSCODE_ARCH)" | Out-File -Encoding ascii -NoNewLine .build\arch
displayName: Prepare tooling
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
exec { git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git" }
exec { git fetch distro }
exec { git merge $(node -p "require('./package.json').distro") }
displayName: Merge distro
- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
inputs:
keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
$env:npm_config_arch="$(VSCODE_ARCH)"
$env:CHILD_CONCURRENCY="1"
exec { yarn --frozen-lockfile }
displayName: Install dependencies
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
inputs:
keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
vstsFeed: 'npm-vscode'
condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
exec { yarn postinstall }
displayName: Run postinstall scripts
condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
exec { node build/azure-pipelines/mixin }
displayName: Mix in quality
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
$env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-min-ci" }
exec { yarn gulp "vscode-reh-win32-$env:VSCODE_ARCH-min-ci" }
exec { yarn gulp "vscode-reh-web-win32-$env:VSCODE_ARCH-min-ci" }
exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-code-helper" }
exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-inno-updater" }
displayName: Build
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
exec { yarn electron $(VSCODE_ARCH) }
exec { .\scripts\test.bat --build --tfs "Unit Tests" }
displayName: Run unit tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- powershell: |
# Figure out the full absolute path of the product we just built
# including the remote server and configure the integration tests
# to run with these builds instead of running out of sources.
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
$AppRoot = "$(agent.builddirectory)\VSCode-win32-$(VSCODE_ARCH)"
$AppProductJson = Get-Content -Raw -Path "$AppRoot\resources\app\product.json" | ConvertFrom-Json
$AppNameShort = $AppProductJson.nameShort
exec { $env:INTEGRATION_TEST_ELECTRON_PATH = "$AppRoot\$AppNameShort.exe"; $env:VSCODE_REMOTE_SERVER_PATH = "$(agent.builddirectory)\vscode-reh-win32-$(VSCODE_ARCH)"; .\scripts\test-integration.bat --build --tfs "Integration Tests" }
displayName: Run integration tests
condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
inputs:
ConnectedServiceName: 'ESRP CodeSign'
FolderPath: '$(agent.builddirectory)/VSCode-win32-$(VSCODE_ARCH),$(agent.builddirectory)/vscode-reh-win32-$(VSCODE_ARCH)'
Pattern: '*.dll,*.exe,*.node'
signConfigType: inlineSignParams
inlineOperation: |
[
{
"keyCode": "CP-230012",
"operationSetCode": "SigntoolSign",
"parameters": [
{
"parameterName": "OpusName",
"parameterValue": "VS Code"
},
{
"parameterName": "OpusInfo",
"parameterValue": "https://code.visualstudio.com/"
},
{
"parameterName": "Append",
"parameterValue": "/as"
},
{
"parameterName": "FileDigest",
"parameterValue": "/fd \"SHA256\""
},
{
"parameterName": "PageHash",
"parameterValue": "/NPH"
},
{
"parameterName": "TimeStamp",
"parameterValue": "/tr \"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer\" /td sha256"
}
],
"toolName": "sign",
"toolVersion": "1.0"
},
{
"keyCode": "CP-230012",
"operationSetCode": "SigntoolVerify",
"parameters": [
{
"parameterName": "VerifyAll",
"parameterValue": "/all"
}
],
"toolName": "sign",
"toolVersion": "1.0"
}
]
SessionTimeout: 120
- task: NuGetCommand@2
displayName: Install ESRPClient.exe
inputs:
restoreSolution: 'build\azure-pipelines\win32\ESRPClient\packages.config'
feedsToUse: config
nugetConfigPath: 'build\azure-pipelines\win32\ESRPClient\NuGet.config'
externalFeedCredentials: 3fc0b7f7-da09-4ae7-a9c8-d69824b1819b
restoreDirectory: packages
- task: ESRPImportCertTask@1
displayName: Import ESRP Request Signing Certificate
inputs:
ESRP: 'ESRP CodeSign'
- powershell: |
$ErrorActionPreference = "Stop"
.\build\azure-pipelines\win32\import-esrp-auth-cert.ps1 -AuthCertificateBase64 $(esrp-auth-certificate) -AuthCertificateKey $(esrp-auth-certificate-key)
displayName: Import ESRP Auth Certificate
- powershell: |
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
$env:AZURE_STORAGE_ACCESS_KEY_2 = "$(vscode-storage-key)"
$env:AZURE_DOCUMENTDB_MASTERKEY = "$(builds-docdb-key-readwrite)"
$env:VSCODE_HOCKEYAPP_TOKEN = "$(vscode-hockeyapp-token)"
$env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
.\build\azure-pipelines\win32\publish.ps1
displayName: Publish
- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
displayName: 'Component Detection'
continueOnError: true
================================================
FILE: build/azure-pipelines/win32/publish.ps1
================================================
. build/azure-pipelines/win32/exec.ps1
$ErrorActionPreference = "Stop"
$Arch = "$env:VSCODE_ARCH"
exec { yarn gulp "vscode-win32-$Arch-archive" "vscode-win32-$Arch-system-setup" "vscode-win32-$Arch-user-setup" --sign }
$Repo = "$(pwd)"
$Root = "$Repo\.."
$SystemExe = "$Repo\.build\win32-$Arch\system-setup\VSCodeSetup.exe"
$UserExe = "$Repo\.build\win32-$Arch\user-setup\VSCodeSetup.exe"
$Zip = "$Repo\.build\win32-$Arch\archive\VSCode-win32-$Arch.zip"
$LegacyServer = "$Root\vscode-reh-win32-$Arch"
$ServerName = "vscode-server-win32-$Arch"
$Server = "$Root\$ServerName"
$ServerZip = "$Repo\.build\vscode-server-win32-$Arch.zip"
$Build = "$Root\VSCode-win32-$Arch"
# Create server archive
exec { Rename-Item -Path $LegacyServer -NewName $ServerName }
exec { .\node_modules\7zip\7zip-lite\7z.exe a -tzip $ServerZip $Server -r }
# get version
$PackageJson = Get-Content -Raw -Path "$Build\resources\app\package.json" | ConvertFrom-Json
$Version = $PackageJson.version
$Quality = "$env:VSCODE_QUALITY"
$AssetPlatform = if ("$Arch" -eq "ia32") { "win32" } else { "win32-x64" }
exec { node build/azure-pipelines/common/publish.js $Quality "$AssetPlatform-archive" archive "VSCode-win32-$Arch-$Version.zip" $Version true $Zip }
exec { node build/azure-pipelines/common/publish.js $Quality "$AssetPlatform" setup "VSCodeSetup-$Arch-$Version.exe" $Version true $SystemExe }
exec { node build/azure-pipelines/common/publish.js $Quality "$AssetPlatform-user" setup "VSCodeUserSetup-$Arch-$Version.exe" $Version true $UserExe }
exec { node build/azure-pipelines/common/publish.js $Quality "server-$AssetPlatform" archive "vscode-server-win32-$Arch.zip" $Version true $ServerZip }
# publish hockeyapp symbols
$hockeyAppId = if ("$Arch" -eq "ia32") { "$env:VSCODE_HOCKEYAPP_ID_WIN32" } else { "$env:VSCODE_HOCKEYAPP_ID_WIN64" }
exec { node build/azure-pipelines/common/symbols.js "$env:VSCODE_MIXIN_PASSWORD" "$env:VSCODE_HOCKEYAPP_TOKEN" "$Arch" $hockeyAppId }
================================================
FILE: build/azure-pipelines/win32/sign.ps1
================================================
function Create-TmpJson($Obj) {
$FileName = [System.IO.Path]::GetTempFileName()
ConvertTo-Json -Depth 100 $Obj | Out-File -Encoding UTF8 $FileName
return $FileName
}
$Auth = Create-TmpJson @{
Version = "1.0.0"
AuthenticationType = "AAD_CERT"
ClientId = $env:ESRPClientId
AuthCert = @{
SubjectName = $env:ESRPAuthCertificateSubjectName
StoreLocation = "LocalMachine"
StoreName = "My"
}
RequestSigningCert = @{
SubjectName = $env:ESRPCertificateSubjectName
StoreLocation = "LocalMachine"
StoreName = "My"
}
}
$Policy = Create-TmpJson @{
Version = "1.0.0"
}
$Input = Create-TmpJson @{
Version = "1.0.0"
SignBatches = @(
@{
SourceLocationType = "UNC"
SignRequestFiles = @(
@{
SourceLocation = $args[0]
}
)
SigningInfo = @{
Operations = @(
@{
KeyCode = "CP-230012"
OperationCode = "SigntoolSign"
Parameters = @{
OpusName = "VS Code"
OpusInfo = "https://code.visualstudio.com/"
Append = "/as"
FileDigest = "/fd `"SHA256`""
PageHash = "/NPH"
TimeStamp = "/tr `"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer`" /td sha256"
}
ToolName = "sign"
ToolVersion = "1.0"
},
@{
KeyCode = "CP-230012"
OperationCode = "SigntoolVerify"
Parameters = @{
VerifyAll = "/all"
}
ToolName = "sign"
ToolVersion = "1.0"
}
)
}
}
)
}
$Output = [System.IO.Path]::GetTempFileName()
$ScriptPath = Split-Path -Path $MyInvocation.MyCommand.Definition -Parent
& "$ScriptPath\ESRPClient\packages\EsrpClient.1.0.27\tools\ESRPClient.exe" Sign -a $Auth -p $Policy -i $Input -o $Output
================================================
FILE: build/builtInExtensions.json
================================================
[
{
"name": "ms-vscode.node-debug",
"version": "1.38.8",
"repo": "https://github.com/Microsoft/vscode-node-debug",
"metadata": {
"id": "b6ded8fb-a0a0-4c1c-acbd-ab2a3bc995a6",
"publisherId": {
"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
"publisherName": "ms-vscode",
"displayName": "Microsoft",
"flags": "verified"
},
"publisherDisplayName": "Microsoft"
}
},
{
"name": "ms-vscode.node-debug2",
"version": "1.39.1",
"repo": "https://github.com/Microsoft/vscode-node-debug2",
"metadata": {
"id": "36d19e17-7569-4841-a001-947eb18602b2",
"publisherId": {
"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
"publisherName": "ms-vscode",
"displayName": "Microsoft",
"flags": "verified"
},
"publisherDisplayName": "Microsoft"
}
},
{
"name": "ms-vscode.references-view",
"version": "0.0.30",
"repo": "https://github.com/Microsoft/vscode-reference-view",
"metadata": {
"id": "dc489f46-520d-4556-ae85-1f9eab3c412d",
"publisherId": {
"publisherId": "5f5636e7-69ed-4afe-b5d6-8d231fb3d3ee",
"publisherName": "ms-vscode",
"displayName": "Microsoft",
"flags": "verified"
},
"publisherDisplayName": "Microsoft"
}
}
]
================================================
FILE: build/builtin/.eslintrc
================================================
{
"env": {
"node": true,
"es6": true,
"browser": true
},
"rules": {
"no-console": 0,
"no-cond-assign": 0,
"no-unused-vars": 1,
"no-extra-semi": "warn",
"semi": "warn"
},
"extends": "eslint:recommended",
"parserOptions": {
"ecmaFeatures": {
"experimentalObjectRestSpread": true
}
}
}
================================================
FILE: build/builtin/browser-main.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
const fs = require('fs');
const path = require('path');
const os = require('os');
// @ts-ignore review
const { remote } = require('electron');
const dialog = remote.dialog;
const builtInExtensionsPath = path.join(__dirname, '..', 'builtInExtensions.json');
const controlFilePath = path.join(os.homedir(), '.vscode-oss-dev', 'extensions', 'control.json');
function readJson(filePath) {
return JSON.parse(fs.readFileSync(filePath, { encoding: 'utf8' }));
}
function writeJson(filePath, obj) {
fs.writeFileSync(filePath, JSON.stringify(obj, null, 2));
}
function renderOption(form, id, title, value, checked) {
const input = document.createElement('input');
input.type = 'radio';
input.id = id;
input.name = 'choice';
input.value = value;
input.checked = !!checked;
form.appendChild(input);
const label = document.createElement('label');
label.setAttribute('for', id);
label.textContent = title;
form.appendChild(label);
return input;
}
function render(el, state) {
function setState(state) {
try {
writeJson(controlFilePath, state.control);
} catch (err) {
console.error(err);
}
el.innerHTML = '';
render(el, state);
}
const ul = document.createElement('ul');
const { builtin, control } = state;
for (const ext of builtin) {
const controlState = control[ext.name] || 'marketplace';
const li = document.createElement('li');
ul.appendChild(li);
const name = document.createElement('code');
name.textContent = ext.name;
li.appendChild(name);
const form = document.createElement('form');
li.appendChild(form);
const marketplaceInput = renderOption(form, `marketplace-${ext.name}`, 'Marketplace', 'marketplace', controlState === 'marketplace');
marketplaceInput.onchange = function () {
control[ext.name] = 'marketplace';
setState({ builtin, control });
};
const disabledInput = renderOption(form, `disabled-${ext.name}`, 'Disabled', 'disabled', controlState === 'disabled');
disabledInput.onchange = function () {
control[ext.name] = 'disabled';
setState({ builtin, control });
};
let local = undefined;
if (controlState !== 'marketplace' && controlState !== 'disabled') {
local = controlState;
}
const localInput = renderOption(form, `local-${ext.name}`, 'Local', 'local', !!local);
localInput.onchange = function () {
const result = dialog.showOpenDialog(remote.getCurrentWindow(), {
title: 'Choose Folder',
properties: ['openDirectory']
});
if (result && result.length >= 1) {
control[ext.name] = result[0];
}
setState({ builtin, control });
};
if (local) {
const localSpan = document.createElement('code');
localSpan.className = 'local';
localSpan.textContent = local;
form.appendChild(localSpan);
}
}
el.appendChild(ul);
}
function main() {
const el = document.getElementById('extensions');
const builtin = readJson(builtInExtensionsPath);
let control;
try {
control = readJson(controlFilePath);
} catch (err) {
control = {};
}
render(el, { builtin, control });
}
window.onload = main;
================================================
FILE: build/builtin/index.html
================================================
Manage Built-in Extensions
Built-in Extensions
================================================
FILE: build/builtin/main.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
const { app, BrowserWindow } = require('electron');
const url = require('url');
const path = require('path');
let window = null;
app.once('ready', () => {
window = new BrowserWindow({ width: 800, height: 600, webPreferences: { nodeIntegration: true, webviewTag: true } });
window.setMenuBarVisibility(false);
window.loadURL(url.format({ pathname: path.join(__dirname, 'index.html'), protocol: 'file:', slashes: true }));
// window.webContents.openDevTools();
window.once('closed', () => window = null);
});
app.on('window-all-closed', () => app.quit());
================================================
FILE: build/builtin/package.json
================================================
{
"name": "builtin",
"version": "0.1.0",
"main": "main.js"
}
================================================
FILE: build/dependencies.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const path = require('path');
const parseSemver = require('parse-semver');
const cp = require('child_process');
const _ = require('underscore');
function asYarnDependency(prefix, tree) {
let parseResult;
try {
parseResult = parseSemver(tree.name);
} catch (err) {
err.message += `: ${tree.name}`;
console.warn(`Could not parse semver: ${tree.name}`);
return null;
}
// not an actual dependency in disk
if (parseResult.version !== parseResult.range) {
return null;
}
const name = parseResult.name;
const version = parseResult.version;
const dependencyPath = path.join(prefix, name);
const children = [];
for (const child of (tree.children || [])) {
const dep = asYarnDependency(path.join(prefix, name, 'node_modules'), child);
if (dep) {
children.push(dep);
}
}
return { name, version, path: dependencyPath, children };
}
function getYarnProductionDependencies(cwd) {
const raw = cp.execSync('yarn list --json', { cwd, encoding: 'utf8', env: { ...process.env, NODE_ENV: 'production' }, stdio: [null, null, 'inherit'] });
const match = /^{"type":"tree".*$/m.exec(raw);
if (!match || match.length !== 1) {
throw new Error('Could not parse result of `yarn list --json`');
}
const trees = JSON.parse(match[0]).data.trees;
return trees
.map(tree => asYarnDependency(path.join(cwd, 'node_modules'), tree))
.filter(dep => !!dep);
}
function getProductionDependencies(cwd) {
const result = [];
const deps = getYarnProductionDependencies(cwd);
const flatten = dep => { result.push({ name: dep.name, version: dep.version, path: dep.path }); dep.children.forEach(flatten); };
deps.forEach(flatten);
return _.uniq(result);
}
module.exports.getProductionDependencies = getProductionDependencies;
if (require.main === module) {
const root = path.dirname(__dirname);
console.log(JSON.stringify(getProductionDependencies(root), null, ' '));
}
================================================
FILE: build/gulpfile.compile.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const util = require('./lib/util');
const task = require('./lib/task');
const compilation = require('./lib/compilation');
// Full compile, including nls and inline sources in sourcemaps, for build
const compileBuildTask = task.define('compile-build', task.series(util.rimraf('out-build'), compilation.compileTask('src', 'out-build', true)));
gulp.task(compileBuildTask);
exports.compileBuildTask = compileBuildTask;
================================================
FILE: build/gulpfile.editor.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
const gulp = require('gulp');
const path = require('path');
const util = require('./lib/util');
const task = require('./lib/task');
const common = require('./lib/optimize');
const es = require('event-stream');
const File = require('vinyl');
const i18n = require('./lib/i18n');
const standalone = require('./lib/standalone');
const cp = require('child_process');
const compilation = require('./lib/compilation');
const monacoapi = require('./monaco/api');
const fs = require('fs');
var root = path.dirname(__dirname);
var sha1 = util.getVersion(root);
var semver = require('./monaco/package.json').version;
var headerVersion = semver + '(' + sha1 + ')';
// Build
var editorEntryPoints = [
{
name: 'vs/editor/editor.main',
include: [],
exclude: ['vs/css', 'vs/nls'],
prepend: ['out-editor-build/vs/css.js', 'out-editor-build/vs/nls.js'],
},
{
name: 'vs/base/common/worker/simpleWorker',
include: ['vs/editor/common/services/editorSimpleWorker'],
prepend: ['vs/loader.js'],
append: ['vs/base/worker/workerMain'],
dest: 'vs/base/worker/workerMain.js'
}
];
var editorResources = [
'out-editor-build/vs/base/browser/ui/codiconLabel/**/*.ttf'
];
var BUNDLED_FILE_HEADER = [
'/*!-----------------------------------------------------------',
' * Copyright (c) Microsoft Corporation. All rights reserved.',
' * Version: ' + headerVersion,
' * Released under the MIT license',
' * https://github.com/Microsoft/vscode/blob/master/LICENSE.txt',
' *-----------------------------------------------------------*/',
''
].join('\n');
const languages = i18n.defaultLanguages.concat([]); // i18n.defaultLanguages.concat(process.env.VSCODE_QUALITY !== 'stable' ? i18n.extraLanguages : []);
const extractEditorSrcTask = task.define('extract-editor-src', () => {
console.log(`If the build fails, consider tweaking shakeLevel below to a lower value.`);
const apiusages = monacoapi.execute().usageContent;
const extrausages = fs.readFileSync(path.join(root, 'build', 'monaco', 'monaco.usage.recipe')).toString();
standalone.extractEditor({
sourcesRoot: path.join(root, 'src'),
entryPoints: [
'vs/editor/editor.main',
'vs/editor/editor.worker',
'vs/base/worker/workerMain',
],
inlineEntryPoints: [
apiusages,
extrausages
],
typings: [
'typings/lib.ie11_safe_es6.d.ts',
'typings/thenable.d.ts',
'typings/es6-promise.d.ts',
'typings/require-monaco.d.ts',
"typings/lib.es2018.promise.d.ts",
'vs/monaco.d.ts'
],
libs: [
`lib.es5.d.ts`,
`lib.dom.d.ts`,
`lib.webworker.importscripts.d.ts`
],
redirects: {
'vs/base/browser/ui/octiconLabel/octiconLabel': 'vs/base/browser/ui/octiconLabel/octiconLabel.mock',
},
shakeLevel: 2, // 0-Files, 1-InnerFile, 2-ClassMembers
importIgnorePattern: /(^vs\/css!)|(promise-polyfill\/polyfill)/,
destRoot: path.join(root, 'out-editor-src')
});
});
const compileEditorAMDTask = task.define('compile-editor-amd', compilation.compileTask('out-editor-src', 'out-editor-build', true));
const optimizeEditorAMDTask = task.define('optimize-editor-amd', common.optimizeTask({
src: 'out-editor-build',
entryPoints: editorEntryPoints,
resources: editorResources,
loaderConfig: {
paths: {
'vs': 'out-editor-build/vs',
'vs/css': 'out-editor-build/vs/css.build',
'vs/nls': 'out-editor-build/vs/nls.build',
'vscode': 'empty:'
}
},
bundleLoader: false,
header: BUNDLED_FILE_HEADER,
bundleInfo: true,
out: 'out-editor',
languages: languages
}));
const minifyEditorAMDTask = task.define('minify-editor-amd', common.minifyTask('out-editor'));
const createESMSourcesAndResourcesTask = task.define('extract-editor-esm', () => {
standalone.createESMSourcesAndResources2({
srcFolder: './out-editor-src',
outFolder: './out-editor-esm',
outResourcesFolder: './out-monaco-editor-core/esm',
ignores: [
'inlineEntryPoint:0.ts',
'inlineEntryPoint:1.ts',
'vs/loader.js',
'vs/nls.ts',
'vs/nls.build.js',
'vs/nls.d.ts',
'vs/css.js',
'vs/css.build.js',
'vs/css.d.ts',
'vs/base/worker/workerMain.ts',
],
renames: {
'vs/nls.mock.ts': 'vs/nls.ts'
}
});
});
const compileEditorESMTask = task.define('compile-editor-esm', () => {
if (process.platform === 'win32') {
const result = cp.spawnSync(`..\\node_modules\\.bin\\tsc.cmd`, {
cwd: path.join(__dirname, '../out-editor-esm')
});
console.log(result.stdout.toString());
console.log(result.stderr.toString());
} else {
const result = cp.spawnSync(`node`, [`../node_modules/.bin/tsc`], {
cwd: path.join(__dirname, '../out-editor-esm')
});
console.log(result.stdout.toString());
console.log(result.stderr.toString());
}
});
function toExternalDTS(contents) {
let lines = contents.split('\n');
let killNextCloseCurlyBrace = false;
for (let i = 0; i < lines.length; i++) {
let line = lines[i];
if (killNextCloseCurlyBrace) {
if ('}' === line) {
lines[i] = '';
killNextCloseCurlyBrace = false;
continue;
}
if (line.indexOf(' ') === 0) {
lines[i] = line.substr(4);
} else if (line.charAt(0) === '\t') {
lines[i] = line.substr(1);
}
continue;
}
if ('declare namespace monaco {' === line) {
lines[i] = '';
killNextCloseCurlyBrace = true;
continue;
}
if (line.indexOf('declare namespace monaco.') === 0) {
lines[i] = line.replace('declare namespace monaco.', 'export namespace ');
}
}
return lines.join('\n');
}
function filterStream(testFunc) {
return es.through(function (data) {
if (!testFunc(data.relative)) {
return;
}
this.emit('data', data);
});
}
const finalEditorResourcesTask = task.define('final-editor-resources', () => {
return es.merge(
// other assets
es.merge(
gulp.src('build/monaco/LICENSE'),
gulp.src('build/monaco/ThirdPartyNotices.txt'),
gulp.src('src/vs/monaco.d.ts')
).pipe(gulp.dest('out-monaco-editor-core')),
// place the .d.ts in the esm folder
gulp.src('src/vs/monaco.d.ts')
.pipe(es.through(function (data) {
this.emit('data', new File({
path: data.path.replace(/monaco\.d\.ts/, 'editor.api.d.ts'),
base: data.base,
contents: Buffer.from(toExternalDTS(data.contents.toString()))
}));
}))
.pipe(gulp.dest('out-monaco-editor-core/esm/vs/editor')),
// package.json
gulp.src('build/monaco/package.json')
.pipe(es.through(function (data) {
var json = JSON.parse(data.contents.toString());
json.private = false;
data.contents = Buffer.from(JSON.stringify(json, null, ' '));
this.emit('data', data);
}))
.pipe(gulp.dest('out-monaco-editor-core')),
// version.txt
gulp.src('build/monaco/version.txt')
.pipe(es.through(function (data) {
data.contents = Buffer.from(`monaco-editor-core: https://github.com/Microsoft/vscode/tree/${sha1}`);
this.emit('data', data);
}))
.pipe(gulp.dest('out-monaco-editor-core')),
// README.md
gulp.src('build/monaco/README-npm.md')
.pipe(es.through(function (data) {
this.emit('data', new File({
path: data.path.replace(/README-npm\.md/, 'README.md'),
base: data.base,
contents: data.contents
}));
}))
.pipe(gulp.dest('out-monaco-editor-core')),
// dev folder
es.merge(
gulp.src('out-editor/**/*')
).pipe(gulp.dest('out-monaco-editor-core/dev')),
// min folder
es.merge(
gulp.src('out-editor-min/**/*')
).pipe(filterStream(function (path) {
// no map files
return !/(\.js\.map$)|(nls\.metadata\.json$)|(bundleInfo\.json$)/.test(path);
})).pipe(es.through(function (data) {
// tweak the sourceMappingURL
if (!/\.js$/.test(data.path)) {
this.emit('data', data);
return;
}
var relativePathToMap = path.relative(path.join(data.relative), path.join('min-maps', data.relative + '.map'));
var strContents = data.contents.toString();
var newStr = '//# sourceMappingURL=' + relativePathToMap.replace(/\\/g, '/');
strContents = strContents.replace(/\/\/# sourceMappingURL=[^ ]+$/, newStr);
data.contents = Buffer.from(strContents);
this.emit('data', data);
})).pipe(gulp.dest('out-monaco-editor-core/min')),
// min-maps folder
es.merge(
gulp.src('out-editor-min/**/*')
).pipe(filterStream(function (path) {
// no map files
return /\.js\.map$/.test(path);
})).pipe(gulp.dest('out-monaco-editor-core/min-maps'))
);
});
gulp.task('editor-distro',
task.series(
task.parallel(
util.rimraf('out-editor-src'),
util.rimraf('out-editor-build'),
util.rimraf('out-editor-esm'),
util.rimraf('out-monaco-editor-core'),
util.rimraf('out-editor'),
util.rimraf('out-editor-min')
),
extractEditorSrcTask,
task.parallel(
task.series(
compileEditorAMDTask,
optimizeEditorAMDTask,
minifyEditorAMDTask
),
task.series(
createESMSourcesAndResourcesTask,
compileEditorESMTask
)
),
finalEditorResourcesTask
)
);
//#region monaco type checking
function createTscCompileTask(watch) {
return () => {
const createReporter = require('./lib/reporter').createReporter;
return new Promise((resolve, reject) => {
const args = ['./node_modules/.bin/tsc', '-p', './src/tsconfig.monaco.json', '--noEmit'];
if (watch) {
args.push('-w');
}
const child = cp.spawn(`node`, args, {
cwd: path.join(__dirname, '..'),
// stdio: [null, 'pipe', 'inherit']
});
let errors = [];
let reporter = createReporter();
let report;
// eslint-disable-next-line no-control-regex
let magic = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g; // https://stackoverflow.com/questions/25245716/remove-all-ansi-colors-styles-from-strings
child.stdout.on('data', data => {
let str = String(data);
str = str.replace(magic, '').trim();
if (str.indexOf('Starting compilation') >= 0 || str.indexOf('File change detected') >= 0) {
errors.length = 0;
report = reporter.end(false);
} else if (str.indexOf('Compilation complete') >= 0) {
report.end();
} else if (str) {
let match = /(.*\(\d+,\d+\): )(.*: )(.*)/.exec(str);
if (match) {
// trying to massage the message so that it matches the gulp-tsb error messages
// e.g. src/vs/base/common/strings.ts(663,5): error TS2322: Type '1234' is not assignable to type 'string'.
let fullpath = path.join(root, match[1]);
let message = match[3];
// @ts-ignore
reporter(fullpath + message);
} else {
// @ts-ignore
reporter(str);
}
}
});
child.on('exit', resolve);
child.on('error', reject);
});
};
}
const monacoTypecheckWatchTask = task.define('monaco-typecheck-watch', createTscCompileTask(true));
exports.monacoTypecheckWatchTask = monacoTypecheckWatchTask;
const monacoTypecheckTask = task.define('monaco-typecheck', createTscCompileTask(false));
exports.monacoTypecheckTask = monacoTypecheckTask;
//#endregion
================================================
FILE: build/gulpfile.extensions.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
// Increase max listeners for event emitters
require('events').EventEmitter.defaultMaxListeners = 100;
const gulp = require('gulp');
const path = require('path');
const tsb = require('gulp-tsb');
const es = require('event-stream');
const filter = require('gulp-filter');
const util = require('./lib/util');
const task = require('./lib/task');
const watcher = require('./lib/watch');
const createReporter = require('./lib/reporter').createReporter;
const glob = require('glob');
const sourcemaps = require('gulp-sourcemaps');
const nlsDev = require('vscode-nls-dev');
const root = path.dirname(__dirname);
const commit = util.getVersion(root);
const plumber = require('gulp-plumber');
const ext = require('./lib/extensions');
const extensionsPath = path.join(path.dirname(__dirname), 'extensions');
const compilations = glob.sync('**/tsconfig.json', {
cwd: extensionsPath,
ignore: ['**/out/**', '**/node_modules/**']
});
const getBaseUrl = out => `https://ticino.blob.core.windows.net/sourcemaps/${commit}/${out}`;
const tasks = compilations.map(function (tsconfigFile) {
const absolutePath = path.join(extensionsPath, tsconfigFile);
const relativeDirname = path.dirname(tsconfigFile);
const overrideOptions = {};
overrideOptions.sourceMap = true;
const name = relativeDirname.replace(/\//g, '-');
const root = path.join('extensions', relativeDirname);
const srcBase = path.join(root, 'src');
const src = path.join(srcBase, '**');
const srcOpts = { cwd: path.dirname(__dirname), base: srcBase };
const out = path.join(root, 'out');
const baseUrl = getBaseUrl(out);
let headerId, headerOut;
let index = relativeDirname.indexOf('/');
if (index < 0) {
headerId = 'vscode.' + relativeDirname;
headerOut = 'out';
} else {
headerId = 'vscode.' + relativeDirname.substr(0, index);
headerOut = relativeDirname.substr(index + 1) + '/out';
}
function createPipeline(build, emitError) {
const reporter = createReporter();
overrideOptions.inlineSources = Boolean(build);
overrideOptions.base = path.dirname(absolutePath);
const compilation = tsb.create(absolutePath, overrideOptions, false, err => reporter(err.toString()));
const pipeline = function () {
const input = es.through();
const tsFilter = filter(['**/*.ts', '!**/lib/lib*.d.ts', '!**/node_modules/**'], { restore: true });
const output = input
.pipe(plumber({
errorHandler: function (err) {
if (err && !err.__reporter__) {
reporter(err);
}
}
}))
.pipe(tsFilter)
.pipe(util.loadSourcemaps())
.pipe(compilation())
.pipe(build ? nlsDev.rewriteLocalizeCalls() : es.through())
.pipe(build ? util.stripSourceMappingURL() : es.through())
.pipe(sourcemaps.write('.', {
sourceMappingURL: !build ? null : f => `${baseUrl}/${f.relative}.map`,
addComment: !!build,
includeContent: !!build,
sourceRoot: '../src'
}))
.pipe(tsFilter.restore)
.pipe(build ? nlsDev.bundleMetaDataFiles(headerId, headerOut) : es.through())
// Filter out *.nls.json file. We needed them only to bundle meta data file.
.pipe(filter(['**', '!**/*.nls.json']))
.pipe(reporter.end(emitError));
return es.duplex(input, output);
};
// add src-stream for project files
pipeline.tsProjectSrc = () => {
return compilation.src(srcOpts);
};
return pipeline;
}
const cleanTask = task.define(`clean-extension-${name}`, util.rimraf(out));
const compileTask = task.define(`compile-extension:${name}`, task.series(cleanTask, () => {
const pipeline = createPipeline(false, true);
const input = pipeline.tsProjectSrc();
return input
.pipe(pipeline())
.pipe(gulp.dest(out));
}));
const watchTask = task.define(`watch-extension:${name}`, task.series(cleanTask, () => {
const pipeline = createPipeline(false);
const input = pipeline.tsProjectSrc();
const watchInput = watcher(src, { ...srcOpts, ...{ readDelay: 200 } });
return watchInput
.pipe(util.incremental(pipeline, input))
.pipe(gulp.dest(out));
}));
const compileBuildTask = task.define(`compile-build-extension-${name}`, task.series(cleanTask, () => {
const pipeline = createPipeline(true, true);
const input = pipeline.tsProjectSrc();
return input
.pipe(pipeline())
.pipe(gulp.dest(out));
}));
// Tasks
gulp.task(compileTask);
gulp.task(watchTask);
return { compileTask, watchTask, compileBuildTask };
});
const compileExtensionsTask = task.define('compile-extensions', task.parallel(...tasks.map(t => t.compileTask)));
gulp.task(compileExtensionsTask);
exports.compileExtensionsTask = compileExtensionsTask;
const watchExtensionsTask = task.define('watch-extensions', task.parallel(...tasks.map(t => t.watchTask)));
gulp.task(watchExtensionsTask);
exports.watchExtensionsTask = watchExtensionsTask;
const compileExtensionsBuildLegacyTask = task.define('compile-extensions-build-legacy', task.parallel(...tasks.map(t => t.compileBuildTask)));
gulp.task(compileExtensionsBuildLegacyTask);
// Azure Pipelines
const cleanExtensionsBuildTask = task.define('clean-extensions-build', util.rimraf('.build/extensions'));
const compileExtensionsBuildTask = task.define('compile-extensions-build', task.series(
cleanExtensionsBuildTask,
task.define('bundle-extensions-build', () => ext.packageLocalExtensionsStream().pipe(gulp.dest('.build'))),
task.define('bundle-marketplace-extensions-build', () => ext.packageMarketplaceExtensionsStream().pipe(gulp.dest('.build'))),
));
gulp.task(compileExtensionsBuildTask);
exports.compileExtensionsBuildTask = compileExtensionsBuildTask;
================================================
FILE: build/gulpfile.hygiene.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const filter = require('gulp-filter');
const es = require('event-stream');
const gulptslint = require('gulp-tslint');
const gulpeslint = require('gulp-eslint');
const tsfmt = require('typescript-formatter');
const tslint = require('tslint');
const VinylFile = require('vinyl');
const vfs = require('vinyl-fs');
const path = require('path');
const fs = require('fs');
const pall = require('p-all');
const task = require('./lib/task');
/**
* Hygiene works by creating cascading subsets of all our files and
* passing them through a sequence of checks. Here are the current subsets,
* named according to the checks performed on them. Each subset contains
* the following one, as described in mathematical notation:
*
* all ⊃ eol ⊇ indentation ⊃ copyright ⊃ typescript
*/
const all = [
'*',
'build/**/*',
'extensions/**/*',
'scripts/**/*',
'src/**/*',
'test/**/*',
'!**/node_modules/**'
];
const indentationFilter = [
'**',
// except specific files
'!ThirdPartyNotices.txt',
'!LICENSE.{txt,rtf}',
'!LICENSES.chromium.html',
'!**/LICENSE',
'!src/vs/nls.js',
'!src/vs/nls.build.js',
'!src/vs/css.js',
'!src/vs/css.build.js',
'!src/vs/loader.js',
'!src/vs/base/common/insane/insane.js',
'!src/vs/base/common/marked/marked.js',
'!src/vs/base/node/terminateProcess.sh',
'!src/vs/base/node/cpuUsage.sh',
'!test/assert.js',
// except specific folders
'!test/automation/out/**',
'!test/smoke/out/**',
'!extensions/vscode-api-tests/testWorkspace/**',
'!extensions/vscode-api-tests/testWorkspace2/**',
'!build/monaco/**',
'!build/win32/**',
// except multiple specific files
'!**/package.json',
'!**/yarn.lock',
'!**/yarn-error.log',
// except multiple specific folders
'!**/octicons/**',
'!**/codicon/**',
'!**/fixtures/**',
'!**/lib/**',
'!extensions/**/out/**',
'!extensions/**/snippets/**',
'!extensions/**/syntaxes/**',
'!extensions/**/themes/**',
'!extensions/**/colorize-fixtures/**',
// except specific file types
'!src/vs/*/**/*.d.ts',
'!src/typings/**/*.d.ts',
'!extensions/**/*.d.ts',
'!**/*.{svg,exe,png,bmp,scpt,bat,cmd,cur,ttf,woff,eot,md,ps1,template,yaml,yml,d.ts.recipe,ico,icns}',
'!build/{lib,tslintRules,download}/**/*.js',
'!build/**/*.sh',
'!build/azure-pipelines/**/*.js',
'!build/azure-pipelines/**/*.config',
'!**/Dockerfile',
'!**/Dockerfile.*',
'!**/*.Dockerfile',
'!**/*.dockerfile',
'!extensions/markdown-language-features/media/*.js'
];
const copyrightFilter = [
'**',
'!**/*.desktop',
'!**/*.json',
'!**/*.html',
'!**/*.template',
'!**/*.md',
'!**/*.bat',
'!**/*.cmd',
'!**/*.ico',
'!**/*.icns',
'!**/*.xml',
'!**/*.sh',
'!**/*.txt',
'!**/*.xpm',
'!**/*.opts',
'!**/*.disabled',
'!**/*.code-workspace',
'!**/promise-polyfill/polyfill.js',
'!build/**/*.init',
'!resources/linux/snap/snapcraft.yaml',
'!resources/linux/snap/electron-launch',
'!resources/win32/bin/code.js',
'!resources/completions/**',
'!extensions/markdown-language-features/media/highlight.css',
'!extensions/html-language-features/server/src/modes/typescript/*',
'!extensions/*/server/bin/*',
'!src/vs/editor/test/node/classification/typescript-test.ts',
'!scripts/code-web.js'
];
const eslintFilter = [
'src/**/*.js',
'build/gulpfile.*.js',
'!src/vs/loader.js',
'!src/vs/css.js',
'!src/vs/nls.js',
'!src/vs/css.build.js',
'!src/vs/nls.build.js',
'!src/**/insane.js',
'!src/**/marked.js',
'!**/test/**'
];
const tslintBaseFilter = [
'!**/fixtures/**',
'!**/typings/**',
'!**/node_modules/**',
'!extensions/typescript-basics/test/colorize-fixtures/**',
'!extensions/vscode-api-tests/testWorkspace/**',
'!extensions/vscode-api-tests/testWorkspace2/**',
'!extensions/**/*.test.ts',
'!extensions/html-language-features/server/lib/jquery.d.ts'
];
const tslintCoreFilter = [
'src/**/*.ts',
'test/**/*.ts',
'!extensions/**/*.ts',
'!test/automation/**',
'!test/smoke/**',
...tslintBaseFilter
];
const tslintExtensionsFilter = [
'extensions/**/*.ts',
'!src/**/*.ts',
'!test/**/*.ts',
'test/automation/**/*.ts',
...tslintBaseFilter
];
const tslintHygieneFilter = [
'src/**/*.ts',
'test/**/*.ts',
'extensions/**/*.ts',
...tslintBaseFilter
];
const copyrightHeaderLines = [
'/*---------------------------------------------------------------------------------------------',
' * Copyright (c) Microsoft Corporation. All rights reserved.',
' * Licensed under the MIT License. See License.txt in the project root for license information.',
' *--------------------------------------------------------------------------------------------*/'
];
gulp.task('eslint', () => {
return vfs.src(all, { base: '.', follow: true, allowEmpty: true })
.pipe(filter(eslintFilter))
.pipe(gulpeslint('src/.eslintrc'))
.pipe(gulpeslint.formatEach('compact'))
.pipe(gulpeslint.failAfterError());
});
gulp.task('tslint', () => {
return es.merge([
// Core: include type information (required by certain rules like no-nodejs-globals)
vfs.src(all, { base: '.', follow: true, allowEmpty: true })
.pipe(filter(tslintCoreFilter))
.pipe(gulptslint.default({ rulesDirectory: 'build/lib/tslint', program: tslint.Linter.createProgram('src/tsconfig.json') }))
.pipe(gulptslint.default.report({ emitError: true })),
// Exenstions: do not include type information
vfs.src(all, { base: '.', follow: true, allowEmpty: true })
.pipe(filter(tslintExtensionsFilter))
.pipe(gulptslint.default({ rulesDirectory: 'build/lib/tslint' }))
.pipe(gulptslint.default.report({ emitError: true }))
]).pipe(es.through());
});
function checkPackageJSON(actualPath) {
const actual = require(path.join(__dirname, '..', actualPath));
const rootPackageJSON = require('../package.json');
for (let depName in actual.dependencies) {
const depVersion = actual.dependencies[depName];
const rootDepVersion = rootPackageJSON.dependencies[depName];
if (!rootDepVersion) {
// missing in root is allowed
continue;
}
if (depVersion !== rootDepVersion) {
this.emit('error', `The dependency ${depName} in '${actualPath}' (${depVersion}) is different than in the root package.json (${rootDepVersion})`);
}
}
}
const checkPackageJSONTask = task.define('check-package-json', () => {
return gulp.src('package.json')
.pipe(es.through(function() {
checkPackageJSON.call(this, 'remote/package.json');
checkPackageJSON.call(this, 'remote/web/package.json');
}));
});
gulp.task(checkPackageJSONTask);
function hygiene(some) {
let errorCount = 0;
const productJson = es.through(function (file) {
const product = JSON.parse(file.contents.toString('utf8'));
if (product.extensionsGallery) {
console.error('product.json: Contains "extensionsGallery"');
errorCount++;
}
this.emit('data', file);
});
const indentation = es.through(function (file) {
const lines = file.contents.toString('utf8').split(/\r\n|\r|\n/);
file.__lines = lines;
lines
.forEach((line, i) => {
if (/^\s*$/.test(line)) {
// empty or whitespace lines are OK
} else if (/^[\t]*[^\s]/.test(line)) {
// good indent
} else if (/^[\t]* \*/.test(line)) {
// block comment using an extra space
} else {
console.error(file.relative + '(' + (i + 1) + ',1): Bad whitespace indentation');
errorCount++;
}
});
this.emit('data', file);
});
const formatting = es.map(function (file, cb) {
tsfmt.processString(file.path, file.contents.toString('utf8'), {
verify: false,
tsfmt: true,
// verbose: true,
// keep checkJS happy
editorconfig: undefined,
replace: undefined,
tsconfig: undefined,
tsconfigFile: undefined,
tslint: undefined,
tslintFile: undefined,
tsfmtFile: undefined,
vscode: undefined,
vscodeFile: undefined
}).then(result => {
let original = result.src.replace(/\r\n/gm, '\n');
let formatted = result.dest.replace(/\r\n/gm, '\n');
if (original !== formatted) {
console.error("File not formatted. Run the 'Format Document' command to fix it:", file.relative);
errorCount++;
}
cb(null, file);
}, err => {
cb(err);
});
});
const tslintConfiguration = tslint.Configuration.findConfiguration('tslint.json', '.');
const tslintOptions = { fix: false, formatter: 'json' };
const tsLinter = new tslint.Linter(tslintOptions);
const tsl = es.through(function (file) {
const contents = file.contents.toString('utf8');
tsLinter.lint(file.relative, contents, tslintConfiguration.results);
this.emit('data', file);
});
let input;
if (Array.isArray(some) || typeof some === 'string' || !some) {
input = vfs.src(some || all, { base: '.', follow: true, allowEmpty: true });
} else {
input = some;
}
const productJsonFilter = filter('product.json', { restore: true });
const result = input
.pipe(filter(f => !f.stat.isDirectory()))
.pipe(productJsonFilter)
.pipe(process.env['BUILD_SOURCEVERSION'] ? es.through() : productJson)
.pipe(productJsonFilter.restore)
.pipe(filter(indentationFilter))
.pipe(indentation)
.pipe(filter(copyrightFilter));
let typescript = result
.pipe(filter(tslintHygieneFilter))
.pipe(formatting);
if (!process.argv.some(arg => arg === '--skip-tslint')) {
typescript = typescript.pipe(tsl);
}
const javascript = result
.pipe(filter(eslintFilter))
.pipe(gulpeslint('src/.eslintrc'))
.pipe(gulpeslint.formatEach('compact'))
.pipe(gulpeslint.failAfterError());
let count = 0;
return es.merge(typescript, javascript)
.pipe(es.through(function (data) {
count++;
if (process.env['TRAVIS'] && count % 10 === 0) {
process.stdout.write('.');
}
this.emit('data', data);
}, function () {
process.stdout.write('\n');
const tslintResult = tsLinter.getResult();
if (tslintResult.failures.length > 0) {
for (const failure of tslintResult.failures) {
const name = failure.getFileName();
const position = failure.getStartPosition();
const line = position.getLineAndCharacter().line;
const character = position.getLineAndCharacter().character;
console.error(`${name}:${line + 1}:${character + 1}:${failure.getFailure()}`);
}
errorCount += tslintResult.failures.length;
}
if (errorCount > 0) {
this.emit('error', 'Hygiene failed with ' + errorCount + ' errors. Check \'build/gulpfile.hygiene.js\'.');
} else {
this.emit('end');
}
}));
}
function createGitIndexVinyls(paths) {
const cp = require('child_process');
const repositoryPath = process.cwd();
const fns = paths.map(relativePath => () => new Promise((c, e) => {
const fullPath = path.join(repositoryPath, relativePath);
fs.stat(fullPath, (err, stat) => {
if (err && err.code === 'ENOENT') { // ignore deletions
return c(null);
} else if (err) {
return e(err);
}
cp.exec(`git show :${relativePath}`, { maxBuffer: 2000 * 1024, encoding: 'buffer' }, (err, out) => {
if (err) {
return e(err);
}
c(new VinylFile({
path: fullPath,
base: repositoryPath,
contents: out,
stat
}));
});
});
}));
return pall(fns, { concurrency: 4 })
.then(r => r.filter(p => !!p));
}
gulp.task('hygiene', task.series(checkPackageJSONTask, () => hygiene()));
// this allows us to run hygiene as a git pre-commit hook
if (require.main === module) {
const cp = require('child_process');
process.on('unhandledRejection', (reason, p) => {
console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
process.exit(1);
});
if (process.argv.length > 2) {
hygiene(process.argv.slice(2)).on('error', err => {
console.error();
console.error(err);
process.exit(1);
});
} else {
cp.exec('git diff --cached --name-only', { maxBuffer: 2000 * 1024 }, (err, out) => {
if (err) {
console.error();
console.error(' pwd:', process.cwd());
console.error(err);
process.exit(1);
return;
}
const some = out
.split(/\r?\n/)
.filter(l => !!l);
if (some.length > 0) {
console.log('Reading git index versions...');
createGitIndexVinyls(some)
.then(vinyls => new Promise((c, e) => hygiene(es.readArray(vinyls))
.on('end', () => c())
.on('error', e)))
.catch(err => {
console.error();
console.error(' pwd:', process.cwd());
console.error(err);
process.exit(1);
});
}
});
}
}
================================================
FILE: build/gulpfile.reh.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const path = require('path');
const es = require('event-stream');
const util = require('./lib/util');
const task = require('./lib/task');
const vfs = require('vinyl-fs');
const flatmap = require('gulp-flatmap');
const gunzip = require('gulp-gunzip');
const untar = require('gulp-untar');
const File = require('vinyl');
const fs = require('fs');
const remote = require('gulp-remote-retry-src');
const rename = require('gulp-rename');
const filter = require('gulp-filter');
const cp = require('child_process');
const REPO_ROOT = path.dirname(__dirname);
const BUILD_TARGETS = [
{ platform: 'win32', arch: 'ia32', pkgTarget: 'node8-win-x86' },
{ platform: 'win32', arch: 'x64', pkgTarget: 'node8-win-x64' },
{ platform: 'darwin', arch: null, pkgTarget: 'node8-macos-x64' },
{ platform: 'linux', arch: 'ia32', pkgTarget: 'node8-linux-x86' },
{ platform: 'linux', arch: 'x64', pkgTarget: 'node8-linux-x64' },
{ platform: 'linux', arch: 'armhf', pkgTarget: 'node8-linux-armv7' },
{ platform: 'linux', arch: 'arm64', pkgTarget: 'node8-linux-arm64' },
{ platform: 'linux', arch: 'alpine', pkgTarget: 'node8-linux-alpine' },
];
const noop = () => { return Promise.resolve(); };
gulp.task('vscode-reh-win32-ia32-min', noop);
gulp.task('vscode-reh-win32-x64-min', noop);
gulp.task('vscode-reh-darwin-min', noop);
gulp.task('vscode-reh-linux-x64-min', noop);
gulp.task('vscode-reh-linux-armhf-min', noop);
gulp.task('vscode-reh-linux-arm64-min', noop);
gulp.task('vscode-reh-linux-alpine-min', noop);
gulp.task('vscode-reh-web-win32-ia32-min', noop);
gulp.task('vscode-reh-web-win32-x64-min', noop);
gulp.task('vscode-reh-web-darwin-min', noop);
gulp.task('vscode-reh-web-linux-x64-min', noop);
gulp.task('vscode-reh-web-linux-alpine-min', noop);
function getNodeVersion() {
const yarnrc = fs.readFileSync(path.join(REPO_ROOT, 'remote', '.yarnrc'), 'utf8');
const target = /^target "(.*)"$/m.exec(yarnrc)[1];
return target;
}
const nodeVersion = getNodeVersion();
BUILD_TARGETS.forEach(({ platform, arch }) => {
if (platform === 'darwin') {
arch = 'x64';
}
gulp.task(task.define(`node-${platform}-${arch}`, () => {
const nodePath = path.join('.build', 'node', `v${nodeVersion}`, `${platform}-${arch}`);
if (!fs.existsSync(nodePath)) {
util.rimraf(nodePath);
return nodejs(platform, arch)
.pipe(vfs.dest(nodePath));
}
return Promise.resolve(null);
}));
});
const defaultNodeTask = gulp.task(`node-${process.platform}-${process.arch}`);
if (defaultNodeTask) {
gulp.task(task.define('node', defaultNodeTask));
}
function nodejs(platform, arch) {
if (arch === 'ia32') {
arch = 'x86';
}
if (platform === 'win32') {
return remote(`/dist/v${nodeVersion}/win-${arch}/node.exe`, { base: 'https://nodejs.org' })
.pipe(rename('node.exe'));
}
if (arch === 'alpine') {
const contents = cp.execSync(`docker run --rm node:${nodeVersion}-alpine /bin/sh -c 'cat \`which node\`'`, { maxBuffer: 100 * 1024 * 1024, encoding: 'buffer' });
return es.readArray([new File({ path: 'node', contents, stat: { mode: parseInt('755', 8) } })]);
}
if (platform === 'darwin') {
arch = 'x64';
}
if (arch === 'armhf') {
arch = 'armv7l';
}
return remote(`/dist/v${nodeVersion}/node-v${nodeVersion}-${platform}-${arch}.tar.gz`, { base: 'https://nodejs.org' })
.pipe(flatmap(stream => stream.pipe(gunzip()).pipe(untar())))
.pipe(filter('**/node'))
.pipe(util.setExecutableBit('**'))
.pipe(rename('node'));
}
function mixinServer(watch) {
const packageJSONPath = path.join(path.dirname(__dirname), 'package.json');
function exec(cmdLine) {
console.log(cmdLine);
cp.execSync(cmdLine, { stdio: "inherit" });
}
function checkout() {
const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath).toString());
exec('git fetch distro');
exec(`git checkout ${packageJSON['distro']} -- src/vs/server resources/server`);
exec('git reset HEAD src/vs/server resources/server');
}
checkout();
if (watch) {
console.log('Enter watch mode (observing package.json)');
const watcher = fs.watch(packageJSONPath);
watcher.addListener('change', () => {
try {
checkout();
} catch (e) {
console.log(e);
}
});
}
return Promise.resolve();
}
gulp.task(task.define('mixin-server', () => mixinServer(false)));
gulp.task(task.define('mixin-server-watch', () => mixinServer(true)));
================================================
FILE: build/gulpfile.vscode.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const fs = require('fs');
const os = require('os');
const cp = require('child_process');
const path = require('path');
const es = require('event-stream');
const azure = require('gulp-azure-storage');
const electron = require('gulp-atom-electron');
const vfs = require('vinyl-fs');
const rename = require('gulp-rename');
const replace = require('gulp-replace');
const filter = require('gulp-filter');
const json = require('gulp-json-editor');
const _ = require('underscore');
const util = require('./lib/util');
const task = require('./lib/task');
const buildfile = require('../src/buildfile');
const common = require('./lib/optimize');
const root = path.dirname(__dirname);
const commit = util.getVersion(root);
const packageJson = require('../package.json');
const product = require('../product.json');
const crypto = require('crypto');
const i18n = require('./lib/i18n');
const deps = require('./dependencies');
const { config } = require('./lib/electron');
const createAsar = require('./lib/asar').createAsar;
const minimist = require('minimist');
const { compileBuildTask } = require('./gulpfile.compile');
const { compileExtensionsBuildTask } = require('./gulpfile.extensions');
const productionDependencies = deps.getProductionDependencies(path.dirname(__dirname));
// @ts-ignore
const baseModules = Object.keys(process.binding('natives')).filter(n => !/^_|\//.test(n));
const nodeModules = ['electron', 'original-fs']
// @ts-ignore JSON checking: dependencies property is optional
.concat(Object.keys(product.dependencies || {}))
.concat(_.uniq(productionDependencies.map(d => d.name)))
.concat(baseModules);
// Build
const vscodeEntryPoints = _.flatten([
buildfile.entrypoint('vs/workbench/workbench.desktop.main'),
buildfile.base,
buildfile.workbenchDesktop,
buildfile.code
]);
const vscodeResources = [
'out-build/main.js',
'out-build/cli.js',
'out-build/driver.js',
'out-build/bootstrap.js',
'out-build/bootstrap-fork.js',
'out-build/bootstrap-amd.js',
'out-build/bootstrap-window.js',
'out-build/paths.js',
'out-build/vs/**/*.{svg,png,html}',
'out-build/vs/kendryte/vs/**/*.{svg,html}',
'!out-build/vs/code/browser/**/*.html',
'out-build/vs/base/common/performance.js',
'out-build/vs/base/node/languagePacks.js',
'out-build/vs/base/node/{stdForkStart.js,terminateProcess.sh,cpuUsage.sh,ps.sh}',
'out-build/vs/base/browser/ui/octiconLabel/octicons/**',
'out-build/vs/base/browser/ui/codiconLabel/codicon/**',
'out-build/vs/workbench/browser/media/*-theme.css',
'out-build/vs/workbench/contrib/debug/**/*.json',
'out-build/vs/workbench/contrib/externalTerminal/**/*.scpt',
'out-build/vs/workbench/contrib/webview/browser/pre/*.js',
'out-build/vs/workbench/contrib/webview/electron-browser/pre/*.js',
'out-build/vs/**/markdown.css',
'out-build/vs/workbench/contrib/tasks/**/*.json',
'out-build/vs/platform/files/**/*.exe',
'out-build/vs/platform/files/**/*.md',
'out-build/vs/code/electron-browser/workbench/**',
'out-build/vs/code/electron-browser/sharedProcess/sharedProcess.js',
'out-build/vs/code/electron-browser/issue/issueReporter.js',
'out-build/vs/code/electron-browser/processExplorer/processExplorer.js',
'!**/test/**'
];
const optimizeVSCodeTask = task.define('optimize-vscode', task.series(
util.rimraf('out-vscode'),
common.optimizeTask({
src: 'out-build',
entryPoints: vscodeEntryPoints,
resources: vscodeResources,
loaderConfig: common.loaderConfig(nodeModules),
out: 'out-vscode',
inlineAmdImages: true,
bundleInfo: undefined
})
));
gulp.task(optimizeVSCodeTask);
const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
const minifyVSCodeTask = task.define('minify-vscode', task.series(
optimizeVSCodeTask,
util.rimraf('out-vscode-min'),
() => {
const fullpath = path.join(process.cwd(), 'out-vscode/bootstrap-window.js');
const contents = fs.readFileSync(fullpath).toString();
const newContents = contents.replace('[/*BUILD->INSERT_NODE_MODULES*/]', JSON.stringify(nodeModules));
fs.writeFileSync(fullpath, newContents);
},
common.minifyTask('out-vscode', `${sourceMappingURLBase}/core`.slice(0, 0))
));
gulp.task(minifyVSCodeTask);
/**
* Compute checksums for some files.
*
* @param {string} out The out folder to read the file from.
* @param {string[]} filenames The paths to compute a checksum for.
* @return {Object} A map of paths to checksums.
*/
function computeChecksums(out, filenames) {
var result = {};
filenames.forEach(function (filename) {
var fullPath = path.join(process.cwd(), out, filename);
result[filename] = computeChecksum(fullPath);
});
return result;
}
/**
* Compute checksum for a file.
*
* @param {string} filename The absolute path to a filename.
* @return {string} The checksum for `filename`.
*/
function computeChecksum(filename) {
var contents = fs.readFileSync(filename);
var hash = crypto
.createHash('md5')
.update(contents)
.digest('base64')
.replace(/=+$/, '');
return hash;
}
function packageTask(platform, arch, sourceFolderName, destinationFolderName, opts) {
opts = opts || {};
const destination = path.join(path.dirname(root), destinationFolderName);
platform = platform || process.platform;
return () => {
const out = sourceFolderName;
const checksums = computeChecksums(out, [
'vs/workbench/workbench.desktop.main.js',
'vs/workbench/workbench.desktop.main.css',
'vs/code/electron-browser/workbench/workbench.html',
'vs/code/electron-browser/workbench/workbench.js'
]);
const src = gulp.src(out + '/**', { base: '.' })
.pipe(rename(function (path) { path.dirname = path.dirname.replace(new RegExp('^' + out), 'out'); }))
.pipe(util.setExecutableBit(['**/*.sh']));
const extensions = gulp.src('.build/extensions/**', { base: '.build', dot: true });
const sources = es.merge(src, extensions)
.pipe(filter(['**'
//, '!**/*.js.map'
], { dot: true }));
let version = packageJson.version;
const quality = product.quality;
if (quality && quality !== 'stable') {
version += '-' + quality;
}
const name = product.nameShort;
const packageJsonUpdates = { name, version };
// for linux url handling
if (platform === 'linux') {
packageJsonUpdates.desktopName = `${product.applicationName}-url-handler.desktop`;
}
const packageJsonStream = gulp.src(['package.json'], { base: '.' })
.pipe(json(packageJsonUpdates));
const date = new Date().toISOString();
const productJsonUpdate = { commit, date, checksums };
if (shouldSetupSettingsSearch()) {
productJsonUpdate.settingsSearchBuildId = getSettingsSearchBuildId(packageJson);
}
const productJsonStream = gulp.src(['product.json'], { base: '.' })
.pipe(json(productJsonUpdate));
const license = gulp.src(['LICENSES.chromium.html', product.licenseFileName, 'ThirdPartyNotices.txt', 'licenses/**'], { base: '.', allowEmpty: true });
// TODO the API should be copied to `out` during compile, not here
const api = gulp.src('src/vs/vscode.d.ts').pipe(rename('out/vs/vscode.d.ts'));
const telemetry = gulp.src('.build/telemetry/**', { base: '.build/telemetry', dot: true });
const root = path.resolve(path.join(__dirname, '..'));
const dependenciesSrc = _.flatten(productionDependencies.map(d => path.relative(root, d.path)).map(d => [`${d}/**`, `!${d}/**/{test,tests}/**`]));
const deps = gulp.src(dependenciesSrc, { base: '.', dot: true })
.pipe(filter(['**', '!**/package-lock.json']))
.pipe(util.cleanNodeModules(path.join(__dirname, '.nativeignore')))
.pipe(createAsar(path.join(process.cwd(), 'node_modules'), ['**/*.node', '**/*.dll', '**/*.exe', '**/vscode-ripgrep/bin/*', '**/node-pty/build/Release/*'], 'app/node_modules.asar'));
let all = es.merge(
packageJsonStream,
productJsonStream,
license,
api,
telemetry,
sources,
deps
);
if (platform === 'win32') {
all = es.merge(all, gulp.src([
'resources/win32/bower.ico',
'resources/win32/c.ico',
'resources/win32/config.ico',
'resources/win32/cpp.ico',
'resources/win32/csharp.ico',
'resources/win32/css.ico',
'resources/win32/default.ico',
'resources/win32/go.ico',
'resources/win32/html.ico',
'resources/win32/jade.ico',
'resources/win32/java.ico',
'resources/win32/javascript.ico',
'resources/win32/json.ico',
'resources/win32/less.ico',
'resources/win32/markdown.ico',
'resources/win32/php.ico',
'resources/win32/powershell.ico',
'resources/win32/python.ico',
'resources/win32/react.ico',
'resources/win32/ruby.ico',
'resources/win32/sass.ico',
'resources/win32/shell.ico',
'resources/win32/sql.ico',
'resources/win32/typescript.ico',
'resources/win32/vue.ico',
'resources/win32/xml.ico',
'resources/win32/yaml.ico',
'resources/win32/code_70x70.png',
'resources/win32/code_150x150.png'
], { base: '.' }));
} else if (platform === 'linux') {
all = es.merge(all, gulp.src('resources/linux/code.png', { base: '.' }));
} else if (platform === 'darwin') {
const shortcut = gulp.src('resources/darwin/bin/code.sh')
.pipe(rename('bin/code'));
all = es.merge(all, shortcut);
}
let result = all
.pipe(util.skipDirectories())
.pipe(util.fixWin32DirectoryPermissions())
.pipe(electron(_.extend({}, config, { platform, arch, ffmpegChromium: true })))
.pipe(filter(['**', '!LICENSE', '!LICENSES.chromium.html', '!version'], { dot: true }));
if (platform === 'linux') {
result = es.merge(result, gulp.src('resources/completions/bash/code', { base: '.' })
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename(function (f) { f.basename = product.applicationName; })));
result = es.merge(result, gulp.src('resources/completions/zsh/_code', { base: '.' })
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename(function (f) { f.basename = '_' + product.applicationName; })));
}
if (platform === 'win32') {
result = es.merge(result, gulp.src('resources/win32/bin/code.js', { base: 'resources/win32', allowEmpty: true }));
result = es.merge(result, gulp.src('resources/win32/bin/code.cmd', { base: 'resources/win32' })
.pipe(replace('@@NAME@@', product.nameShort))
.pipe(rename(function (f) { f.basename = product.applicationName; })));
result = es.merge(result, gulp.src('resources/win32/bin/code.sh', { base: 'resources/win32' })
.pipe(replace('@@NAME@@', product.nameShort))
.pipe(replace('@@PRODNAME@@', product.nameLong))
.pipe(replace('@@VERSION@@', version))
.pipe(replace('@@COMMIT@@', commit))
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(replace('@@DATAFOLDER@@', product.dataFolderName))
.pipe(replace('@@QUALITY@@', quality))
.pipe(rename(function (f) { f.basename = product.applicationName; f.extname = ''; })));
result = es.merge(result, gulp.src('resources/win32/VisualElementsManifest.xml', { base: 'resources/win32' })
.pipe(rename(product.nameShort + '.VisualElementsManifest.xml')));
} else if (platform === 'linux') {
result = es.merge(result, gulp.src('resources/linux/bin/code.sh', { base: '.' })
.pipe(replace('@@PRODNAME@@', product.nameLong))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(rename('bin/' + product.applicationName)));
}
// submit all stats that have been collected
// during the build phase
if (opts.stats) {
result.on('end', () => {
const { submitAllStats } = require('./lib/stats');
submitAllStats(product, commit).then(() => console.log('Submitted bundle stats!'));
});
}
return result.pipe(vfs.dest(destination));
};
}
const buildRoot = path.dirname(root);
const BUILD_TARGETS = [
{ platform: 'win32', arch: 'ia32' },
{ platform: 'win32', arch: 'x64' },
{ platform: 'darwin', arch: null, opts: { stats: true } },
{ platform: 'linux', arch: 'ia32' },
{ platform: 'linux', arch: 'x64' },
{ platform: 'linux', arch: 'arm' },
{ platform: 'linux', arch: 'arm64' },
];
BUILD_TARGETS.forEach(buildTarget => {
const dashed = (str) => (str ? `-${str}` : ``);
const platform = buildTarget.platform;
const arch = buildTarget.arch;
const opts = buildTarget.opts;
['', 'min'].forEach(minified => {
const sourceFolderName = `out-vscode${dashed(minified)}`;
const destinationFolderName = `VSCode${dashed(platform)}${dashed(arch)}`;
const vscodeTaskCI = task.define(`vscode${dashed(platform)}${dashed(arch)}${dashed(minified)}-ci`, task.series(
util.rimraf(path.join(buildRoot, destinationFolderName)),
packageTask(platform, arch, sourceFolderName, destinationFolderName, opts)
));
gulp.task(vscodeTaskCI);
const vscodeTask = task.define(`vscode${dashed(platform)}${dashed(arch)}${dashed(minified)}`, task.series(
compileBuildTask,
compileExtensionsBuildTask,
minified ? minifyVSCodeTask : optimizeVSCodeTask,
vscodeTaskCI
));
gulp.task(vscodeTask);
});
});
// Transifex Localizations
const innoSetupConfig = {
'zh-cn': { codePage: 'CP936', defaultInfo: { name: 'Simplified Chinese', id: '$0804', } },
'zh-tw': { codePage: 'CP950', defaultInfo: { name: 'Traditional Chinese', id: '$0404' } },
'ko': { codePage: 'CP949', defaultInfo: { name: 'Korean', id: '$0412' } },
'ja': { codePage: 'CP932' },
'de': { codePage: 'CP1252' },
'fr': { codePage: 'CP1252' },
'es': { codePage: 'CP1252' },
'ru': { codePage: 'CP1251' },
'it': { codePage: 'CP1252' },
'pt-br': { codePage: 'CP1252' },
'hu': { codePage: 'CP1250' },
'tr': { codePage: 'CP1254' }
};
const apiHostname = process.env.TRANSIFEX_API_URL;
const apiName = process.env.TRANSIFEX_API_NAME;
const apiToken = process.env.TRANSIFEX_API_TOKEN;
gulp.task(task.define(
'vscode-translations-push',
task.series(
compileBuildTask,
compileExtensionsBuildTask,
optimizeVSCodeTask,
function () {
const pathToMetadata = './out-vscode/nls.metadata.json';
const pathToExtensions = '.build/extensions/*';
const pathToSetup = 'build/win32/**/{Default.isl,messages.en.isl}';
return es.merge(
gulp.src(pathToMetadata).pipe(i18n.createXlfFilesForCoreBundle()),
gulp.src(pathToSetup).pipe(i18n.createXlfFilesForIsl()),
gulp.src(pathToExtensions).pipe(i18n.createXlfFilesForExtensions())
).pipe(i18n.findObsoleteResources(apiHostname, apiName, apiToken)
).pipe(i18n.pushXlfFiles(apiHostname, apiName, apiToken));
}
)
));
gulp.task(task.define(
'vscode-translations-export',
task.series(
compileBuildTask,
compileExtensionsBuildTask,
optimizeVSCodeTask,
function () {
const pathToMetadata = './out-vscode/nls.metadata.json';
const pathToExtensions = '.build/extensions/*';
const pathToSetup = 'build/win32/**/{Default.isl,messages.en.isl}';
return es.merge(
gulp.src(pathToMetadata).pipe(i18n.createXlfFilesForCoreBundle()),
gulp.src(pathToSetup).pipe(i18n.createXlfFilesForIsl()),
gulp.src(pathToExtensions).pipe(i18n.createXlfFilesForExtensions())
).pipe(vfs.dest('../vscode-translations-export'));
}
)
));
gulp.task('vscode-translations-pull', function () {
return es.merge([...i18n.defaultLanguages, ...i18n.extraLanguages].map(language => {
let includeDefault = !!innoSetupConfig[language.id].defaultInfo;
return i18n.pullSetupXlfFiles(apiHostname, apiName, apiToken, language, includeDefault).pipe(vfs.dest(`../vscode-translations-import/${language.id}/setup`));
}));
});
gulp.task('vscode-translations-import', function () {
var options = minimist(process.argv.slice(2), {
string: 'location',
default: {
location: '../vscode-translations-import'
}
});
return es.merge([...i18n.defaultLanguages, ...i18n.extraLanguages].map(language => {
let id = language.transifexId || language.id;
return gulp.src(`${options.location}/${id}/setup/*/*.xlf`)
.pipe(i18n.prepareIslFiles(language, innoSetupConfig[language.id]))
.pipe(vfs.dest(`./build/win32/i18n`));
}));
});
// This task is only run for the MacOS build
const generateVSCodeConfigurationTask = task.define('generate-vscode-configuration', () => {
return new Promise((resolve, reject) => {
const buildDir = process.env['AGENT_BUILDDIRECTORY'];
if (!buildDir) {
return reject(new Error('$AGENT_BUILDDIRECTORY not set'));
}
if (process.env.VSCODE_QUALITY !== 'insider' && process.env.VSCODE_QUALITY !== 'stable') {
return resolve();
}
const userDataDir = path.join(os.tmpdir(), 'tmpuserdata');
const extensionsDir = path.join(os.tmpdir(), 'tmpextdir');
const appName = process.env.VSCODE_QUALITY === 'insider' ? 'Visual\\ Studio\\ Code\\ -\\ Insiders.app' : 'Visual\\ Studio\\ Code.app';
const appPath = path.join(buildDir, `VSCode-darwin/${appName}/Contents/Resources/app/bin/code`);
const codeProc = cp.exec(`${appPath} --export-default-configuration='${allConfigDetailsPath}' --wait --user-data-dir='${userDataDir}' --extensions-dir='${extensionsDir}'`);
const timer = setTimeout(() => {
codeProc.kill();
reject(new Error('export-default-configuration process timed out'));
}, 10 * 1000);
codeProc.stdout.on('data', d => console.log(d.toString()));
codeProc.stderr.on('data', d => console.log(d.toString()));
codeProc.on('exit', () => {
clearTimeout(timer);
resolve();
});
codeProc.on('error', err => {
clearTimeout(timer);
reject(err);
});
});
});
const allConfigDetailsPath = path.join(os.tmpdir(), 'configuration.json');
gulp.task(task.define(
'upload-vscode-configuration',
task.series(
generateVSCodeConfigurationTask,
() => {
if (!shouldSetupSettingsSearch()) {
const branch = process.env.BUILD_SOURCEBRANCH;
console.log(`Only runs on master and release branches, not ${branch}`);
return;
}
if (!fs.existsSync(allConfigDetailsPath)) {
throw new Error(`configuration file at ${allConfigDetailsPath} does not exist`);
}
const settingsSearchBuildId = getSettingsSearchBuildId(packageJson);
if (!settingsSearchBuildId) {
throw new Error('Failed to compute build number');
}
return gulp.src(allConfigDetailsPath)
.pipe(azure.upload({
account: process.env.AZURE_STORAGE_ACCOUNT,
key: process.env.AZURE_STORAGE_ACCESS_KEY,
container: 'configuration',
prefix: `${settingsSearchBuildId}/${commit}/`
}));
}
)
));
function shouldSetupSettingsSearch() {
const branch = process.env.BUILD_SOURCEBRANCH;
return branch && (/\/master$/.test(branch) || branch.indexOf('/release/') >= 0);
}
function getSettingsSearchBuildId(packageJson) {
try {
const branch = process.env.BUILD_SOURCEBRANCH;
const branchId = branch.indexOf('/release/') >= 0 ? 0 :
/\/master$/.test(branch) ? 1 :
2; // Some unexpected branch
const out = cp.execSync(`git rev-list HEAD --count`);
const count = parseInt(out.toString());
//
// 1.25.1, 1,234,567 commits, master = 1250112345671
return util.versionStringToNumber(packageJson.version) * 1e8 + count * 10 + branchId;
} catch (e) {
throw new Error('Could not determine build number: ' + e.toString());
}
}
================================================
FILE: build/gulpfile.vscode.linux.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const replace = require('gulp-replace');
const rename = require('gulp-rename');
const shell = require('gulp-shell');
const es = require('event-stream');
const vfs = require('vinyl-fs');
const util = require('./lib/util');
const task = require('./lib/task');
const packageJson = require('../package.json');
const product = require('../product.json');
const rpmDependencies = require('../resources/linux/rpm/dependencies.json');
const path = require('path');
const root = path.dirname(__dirname);
const commit = util.getVersion(root);
const linuxPackageRevision = Math.floor(new Date().getTime() / 1000);
function getDebPackageArch(arch) {
return { x64: 'amd64', arm: 'armhf', arm64: "arm64" }[arch];
}
function prepareDebPackage(arch) {
const binaryDir = '../VSCode-linux-' + arch;
const debArch = getDebPackageArch(arch);
const destination = '.build/linux/deb/' + debArch + '/' + product.applicationName + '-' + debArch;
return function () {
const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
.pipe(rename('usr/share/applications/' + product.applicationName + '.desktop'));
const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
.pipe(rename('usr/share/applications/' + product.applicationName + '-url-handler.desktop'));
const desktops = es.merge(desktop, desktopUrlHandler)
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@NAME_SHORT@@', product.nameShort))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@EXEC@@', `/usr/share/${product.applicationName}/${product.applicationName}`))
.pipe(replace('@@ICON@@', `/usr/share/pixmaps/${product.linuxIconName}.png`))
.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
const appdata = gulp.src('resources/linux/code.appdata.xml', { base: '.' })
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@LICENSE@@', product.licenseName))
.pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml'));
const icon = gulp.src('resources/linux/code.png', { base: '.' })
.pipe(rename('usr/share/pixmaps/' + product.linuxIconName + '.png'));
const bash_completion = gulp.src('resources/completions/bash/code')
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename('usr/share/bash-completion/completions/' + product.applicationName));
const zsh_completion = gulp.src('resources/completions/zsh/_code')
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename('usr/share/zsh/vendor-completions/_' + product.applicationName));
const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
.pipe(rename(function (p) { p.dirname = 'usr/share/' + product.applicationName + '/' + p.dirname; }));
let size = 0;
const control = code.pipe(es.through(
function (f) { size += f.isDirectory() ? 4096 : f.contents.length; },
function () {
const that = this;
gulp.src('resources/linux/debian/control.template', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@VERSION@@', packageJson.version + '-' + linuxPackageRevision))
.pipe(replace('@@ARCHITECTURE@@', debArch))
.pipe(replace('@@INSTALLEDSIZE@@', Math.ceil(size / 1024)))
.pipe(rename('DEBIAN/control'))
.pipe(es.through(function (f) { that.emit('data', f); }, function () { that.emit('end'); }));
}));
const prerm = gulp.src('resources/linux/debian/prerm.template', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(rename('DEBIAN/prerm'));
const postrm = gulp.src('resources/linux/debian/postrm.template', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(rename('DEBIAN/postrm'));
const postinst = gulp.src('resources/linux/debian/postinst.template', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@ARCHITECTURE@@', debArch))
// @ts-ignore JSON checking: quality is optional
.pipe(replace('@@QUALITY@@', product.quality || '@@QUALITY@@'))
// @ts-ignore JSON checking: updateUrl is optional
.pipe(replace('@@UPDATEURL@@', product.updateUrl || '@@UPDATEURL@@'))
.pipe(rename('DEBIAN/postinst'));
const all = es.merge(control, postinst, postrm, prerm, desktops, appdata, icon, bash_completion, zsh_completion, code);
return all.pipe(vfs.dest(destination));
};
}
function buildDebPackage(arch) {
const debArch = getDebPackageArch(arch);
return shell.task([
'chmod 755 ' + product.applicationName + '-' + debArch + '/DEBIAN/postinst ' + product.applicationName + '-' + debArch + '/DEBIAN/prerm ' + product.applicationName + '-' + debArch + '/DEBIAN/postrm',
'mkdir -p deb',
'fakeroot dpkg-deb -b ' + product.applicationName + '-' + debArch + ' deb'
], { cwd: '.build/linux/deb/' + debArch });
}
function getRpmBuildPath(rpmArch) {
return '.build/linux/rpm/' + rpmArch + '/rpmbuild';
}
function getRpmPackageArch(arch) {
return { x64: 'x86_64', arm: 'armhf', arm64: "arm64" }[arch];
}
function prepareRpmPackage(arch) {
const binaryDir = '../VSCode-linux-' + arch;
const rpmArch = getRpmPackageArch(arch);
return function () {
const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
.pipe(rename('BUILD/usr/share/applications/' + product.applicationName + '.desktop'));
const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
.pipe(rename('BUILD/usr/share/applications/' + product.applicationName + '-url-handler.desktop'));
const desktops = es.merge(desktop, desktopUrlHandler)
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@NAME_SHORT@@', product.nameShort))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@EXEC@@', `/usr/share/${product.applicationName}/${product.applicationName}`))
.pipe(replace('@@ICON@@', product.linuxIconName))
.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
const appdata = gulp.src('resources/linux/code.appdata.xml', { base: '.' })
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@LICENSE@@', product.licenseName))
.pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml'));
const icon = gulp.src('resources/linux/code.png', { base: '.' })
.pipe(rename('BUILD/usr/share/pixmaps/' + product.linuxIconName + '.png'));
const bash_completion = gulp.src('resources/completions/bash/code')
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename('BUILD/usr/share/bash-completion/completions/' + product.applicationName));
const zsh_completion = gulp.src('resources/completions/zsh/_code')
.pipe(replace('@@APPNAME@@', product.applicationName))
.pipe(rename('BUILD/usr/share/zsh/site-functions/_' + product.applicationName));
const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
.pipe(rename(function (p) { p.dirname = 'BUILD/usr/share/' + product.applicationName + '/' + p.dirname; }));
const spec = gulp.src('resources/linux/rpm/code.spec.template', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@ICON@@', product.linuxIconName))
.pipe(replace('@@VERSION@@', packageJson.version))
.pipe(replace('@@RELEASE@@', linuxPackageRevision))
.pipe(replace('@@ARCHITECTURE@@', rpmArch))
.pipe(replace('@@LICENSE@@', product.licenseName))
// @ts-ignore JSON checking: quality is optional
.pipe(replace('@@QUALITY@@', product.quality || '@@QUALITY@@'))
// @ts-ignore JSON checking: updateUrl is optional
.pipe(replace('@@UPDATEURL@@', product.updateUrl || '@@UPDATEURL@@'))
.pipe(replace('@@DEPENDENCIES@@', rpmDependencies[rpmArch].join(', ')))
.pipe(rename('SPECS/' + product.applicationName + '.spec'));
const specIcon = gulp.src('resources/linux/rpm/code.xpm', { base: '.' })
.pipe(rename('SOURCES/' + product.applicationName + '.xpm'));
const all = es.merge(code, desktops, appdata, icon, bash_completion, zsh_completion, spec, specIcon);
return all.pipe(vfs.dest(getRpmBuildPath(rpmArch)));
};
}
function buildRpmPackage(arch) {
const rpmArch = getRpmPackageArch(arch);
const rpmBuildPath = getRpmBuildPath(rpmArch);
const rpmOut = rpmBuildPath + '/RPMS/' + rpmArch;
const destination = '.build/linux/rpm/' + rpmArch;
return shell.task([
'mkdir -p ' + destination,
'HOME="$(pwd)/' + destination + '" fakeroot rpmbuild -bb ' + rpmBuildPath + '/SPECS/' + product.applicationName + '.spec --target=' + rpmArch,
'cp "' + rpmOut + '/$(ls ' + rpmOut + ')" ' + destination + '/'
]);
}
function getSnapBuildPath(arch) {
return `.build/linux/snap/${arch}/${product.applicationName}-${arch}`;
}
function prepareSnapPackage(arch) {
const binaryDir = '../VSCode-linux-' + arch;
const destination = getSnapBuildPath(arch);
return function () {
// A desktop file that is placed in snap/gui will be placed into meta/gui verbatim.
const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
.pipe(rename(`snap/gui/${product.applicationName}.desktop`));
// A desktop file that is placed in snap/gui will be placed into meta/gui verbatim.
const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
.pipe(rename(`snap/gui/${product.applicationName}-url-handler.desktop`));
const desktops = es.merge(desktop, desktopUrlHandler)
.pipe(replace('@@NAME_LONG@@', product.nameLong))
.pipe(replace('@@NAME_SHORT@@', product.nameShort))
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@EXEC@@', `${product.applicationName} --force-user-env`))
.pipe(replace('@@ICON@@', `\${SNAP}/meta/gui/${product.linuxIconName}.png`))
.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
// An icon that is placed in snap/gui will be placed into meta/gui verbatim.
const icon = gulp.src('resources/linux/code.png', { base: '.' })
.pipe(rename(`snap/gui/${product.linuxIconName}.png`));
const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
.pipe(rename(function (p) { p.dirname = `usr/share/${product.applicationName}/${p.dirname}`; }));
const snapcraft = gulp.src('resources/linux/snap/snapcraft.yaml', { base: '.' })
.pipe(replace('@@NAME@@', product.applicationName))
.pipe(replace('@@VERSION@@', commit.substr(0, 8)))
.pipe(rename('snap/snapcraft.yaml'));
const electronLaunch = gulp.src('resources/linux/snap/electron-launch', { base: '.' })
.pipe(rename('electron-launch'));
const all = es.merge(desktops, icon, code, snapcraft, electronLaunch);
return all.pipe(vfs.dest(destination));
};
}
function buildSnapPackage(arch) {
const snapBuildPath = getSnapBuildPath(arch);
// Default target for snapcraft runs: pull, build, stage and prime, and finally assembles the snap.
return shell.task(`cd ${snapBuildPath} && snapcraft`);
}
const BUILD_TARGETS = [
{ arch: 'x64' },
{ arch: 'arm' },
{ arch: 'arm64' },
];
BUILD_TARGETS.forEach((buildTarget) => {
const arch = buildTarget.arch;
{
const debArch = getDebPackageArch(arch);
const prepareDebTask = task.define(`vscode-linux-${arch}-prepare-deb`, task.series(util.rimraf(`.build/linux/deb/${debArch}`), prepareDebPackage(arch)));
// gulp.task(prepareDebTask);
const buildDebTask = task.define(`vscode-linux-${arch}-build-deb`, task.series(prepareDebTask, buildDebPackage(arch)));
gulp.task(buildDebTask);
}
{
const rpmArch = getRpmPackageArch(arch);
const prepareRpmTask = task.define(`vscode-linux-${arch}-prepare-rpm`, task.series(util.rimraf(`.build/linux/rpm/${rpmArch}`), prepareRpmPackage(arch)));
// gulp.task(prepareRpmTask);
const buildRpmTask = task.define(`vscode-linux-${arch}-build-rpm`, task.series(prepareRpmTask, buildRpmPackage(arch)));
gulp.task(buildRpmTask);
}
{
const prepareSnapTask = task.define(`vscode-linux-${arch}-prepare-snap`, task.series(util.rimraf(`.build/linux/snap/${arch}`), prepareSnapPackage(arch)));
gulp.task(prepareSnapTask);
const buildSnapTask = task.define(`vscode-linux-${arch}-build-snap`, task.series(prepareSnapTask, buildSnapPackage(arch)));
gulp.task(buildSnapTask);
}
});
================================================
FILE: build/gulpfile.vscode.web.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const noop = () => { return Promise.resolve(); };
gulp.task('minify-vscode-web', noop);
gulp.task('vscode-web', noop);
gulp.task('vscode-web-min', noop);
gulp.task('vscode-web-ci', noop);
gulp.task('vscode-web-min-ci', noop);
================================================
FILE: build/gulpfile.vscode.win32.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const gulp = require('gulp');
const path = require('path');
const fs = require('fs');
const assert = require('assert');
const cp = require('child_process');
const _7z = require('7zip')['7z'];
const util = require('./lib/util');
const task = require('./lib/task');
const pkg = require('../package.json');
const product = require('../product.json');
const vfs = require('vinyl-fs');
const rcedit = require('rcedit');
const mkdirp = require('mkdirp');
const repoPath = path.dirname(__dirname);
const buildPath = arch => path.join(path.dirname(repoPath), `VSCode-win32-${arch}`);
const zipDir = arch => path.join(repoPath, '.build', `win32-${arch}`, 'archive');
const zipPath = arch => path.join(zipDir(arch), `VSCode-win32-${arch}.zip`);
const setupDir = (arch, target) => path.join(repoPath, '.build', `win32-${arch}`, `${target}-setup`);
const issPath = path.join(__dirname, 'win32', 'code.iss');
const innoSetupPath = path.join(path.dirname(path.dirname(require.resolve('innosetup'))), 'bin', 'ISCC.exe');
const signPS1 = path.join(repoPath, 'build', 'azure-pipelines', 'win32', 'sign.ps1');
function packageInnoSetup(iss, options, cb) {
options = options || {};
const definitions = options.definitions || {};
if (process.argv.some(arg => arg === '--debug-inno')) {
definitions['Debug'] = 'true';
}
if (process.argv.some(arg => arg === '--sign')) {
definitions['Sign'] = 'true';
}
const keys = Object.keys(definitions);
keys.forEach(key => assert(typeof definitions[key] === 'string', `Missing value for '${key}' in Inno Setup package step`));
const defs = keys.map(key => `/d${key}=${definitions[key]}`);
const args = [
iss,
...defs,
`/sesrp=powershell.exe -ExecutionPolicy bypass ${signPS1} $f`
];
cp.spawn(innoSetupPath, args, { stdio: ['ignore', 'inherit', 'inherit'] })
.on('error', cb)
.on('exit', () => cb(null));
}
function buildWin32Setup(arch, target) {
if (target !== 'system' && target !== 'user') {
throw new Error('Invalid setup target');
}
return cb => {
const ia32AppId = target === 'system' ? product.win32AppId : product.win32UserAppId;
const x64AppId = target === 'system' ? product.win32x64AppId : product.win32x64UserAppId;
const sourcePath = buildPath(arch);
const outputPath = setupDir(arch, target);
mkdirp.sync(outputPath);
const originalProductJsonPath = path.join(sourcePath, 'resources/app/product.json');
const productJsonPath = path.join(outputPath, 'product.json');
const productJson = JSON.parse(fs.readFileSync(originalProductJsonPath, 'utf8'));
productJson['target'] = target;
fs.writeFileSync(productJsonPath, JSON.stringify(productJson, undefined, '\t'));
const definitions = {
NameLong: product.nameLong,
NameShort: product.nameShort,
DirName: product.win32DirName,
Version: pkg.version,
RawVersion: pkg.version.replace(/-\w+$/, ''),
NameVersion: product.win32NameVersion + (target === 'user' ? ' (User)' : ''),
ExeBasename: product.nameShort,
RegValueName: product.win32RegValueName,
ShellNameShort: product.win32ShellNameShort,
AppMutex: product.win32MutexName,
Arch: arch,
AppId: arch === 'ia32' ? ia32AppId : x64AppId,
IncompatibleTargetAppId: arch === 'ia32' ? product.win32AppId : product.win32x64AppId,
IncompatibleArchAppId: arch === 'ia32' ? x64AppId : ia32AppId,
AppUserId: product.win32AppUserModelId,
ArchitecturesAllowed: arch === 'ia32' ? '' : 'x64',
ArchitecturesInstallIn64BitMode: arch === 'ia32' ? '' : 'x64',
SourceDir: sourcePath,
RepoDir: repoPath,
OutputDir: outputPath,
InstallTarget: target,
ProductJsonPath: productJsonPath
};
packageInnoSetup(issPath, { definitions }, cb);
};
}
function defineWin32SetupTasks(arch, target) {
const cleanTask = util.rimraf(setupDir(arch, target));
gulp.task(task.define(`vscode-win32-${arch}-${target}-setup`, task.series(cleanTask, buildWin32Setup(arch, target))));
}
defineWin32SetupTasks('ia32', 'system');
defineWin32SetupTasks('x64', 'system');
defineWin32SetupTasks('ia32', 'user');
defineWin32SetupTasks('x64', 'user');
function archiveWin32Setup(arch) {
return cb => {
const args = ['a', '-tzip', zipPath(arch), '-x!CodeSignSummary*.md', '.', '-r'];
cp.spawn(_7z, args, { stdio: 'inherit', cwd: buildPath(arch) })
.on('error', cb)
.on('exit', () => cb(null));
};
}
gulp.task(task.define('vscode-win32-ia32-archive', task.series(util.rimraf(zipDir('ia32')), archiveWin32Setup('ia32'))));
gulp.task(task.define('vscode-win32-x64-archive', task.series(util.rimraf(zipDir('x64')), archiveWin32Setup('x64'))));
function copyInnoUpdater(arch) {
return () => {
return gulp.src('build/win32/{inno_updater.exe,vcruntime140.dll}', { base: 'build/win32' })
.pipe(vfs.dest(path.join(buildPath(arch), 'tools')));
};
}
function updateIcon(executablePath) {
return cb => {
const icon = path.join(repoPath, 'resources', 'win32', 'code.ico');
rcedit(executablePath, { icon }, cb);
};
}
gulp.task(task.define('vscode-win32-ia32-inno-updater', task.series(copyInnoUpdater('ia32'), updateIcon(path.join(buildPath('ia32'), 'tools', 'inno_updater.exe')))));
gulp.task(task.define('vscode-win32-x64-inno-updater', task.series(copyInnoUpdater('x64'), updateIcon(path.join(buildPath('x64'), 'tools', 'inno_updater.exe')))));
// CodeHelper.exe icon
gulp.task(task.define('vscode-win32-ia32-code-helper', task.series(updateIcon(path.join(buildPath('ia32'), 'resources', 'app', 'out', 'vs', 'platform', 'files', 'node', 'watcher', 'win32', 'CodeHelper.exe')))));
gulp.task(task.define('vscode-win32-x64-code-helper', task.series(updateIcon(path.join(buildPath('x64'), 'resources', 'app', 'out', 'vs', 'platform', 'files', 'node', 'watcher', 'win32', 'CodeHelper.exe')))));
================================================
FILE: build/jsconfig.json
================================================
{
"compilerOptions": {
"module": "commonjs",
"target": "es2017",
"jsx": "preserve",
"checkJs": true
},
"include": [
"**/*.js"
],
"exclude": [
"node_modules",
"**/node_modules/*"
]
}
================================================
FILE: build/lib/asar.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const path = require("path");
const es = require("event-stream");
const pickle = require('chromium-pickle-js');
const Filesystem = require('asar/lib/filesystem');
const VinylFile = require("vinyl");
const minimatch = require("minimatch");
function createAsar(folderPath, unpackGlobs, destFilename) {
const shouldUnpackFile = (file) => {
for (let i = 0; i < unpackGlobs.length; i++) {
if (minimatch(file.relative, unpackGlobs[i])) {
return true;
}
}
return false;
};
const filesystem = new Filesystem(folderPath);
const out = [];
// Keep track of pending inserts
let pendingInserts = 0;
let onFileInserted = () => { pendingInserts--; };
// Do not insert twice the same directory
const seenDir = {};
const insertDirectoryRecursive = (dir) => {
if (seenDir[dir]) {
return;
}
let lastSlash = dir.lastIndexOf('/');
if (lastSlash === -1) {
lastSlash = dir.lastIndexOf('\\');
}
if (lastSlash !== -1) {
insertDirectoryRecursive(dir.substring(0, lastSlash));
}
seenDir[dir] = true;
filesystem.insertDirectory(dir);
};
const insertDirectoryForFile = (file) => {
let lastSlash = file.lastIndexOf('/');
if (lastSlash === -1) {
lastSlash = file.lastIndexOf('\\');
}
if (lastSlash !== -1) {
insertDirectoryRecursive(file.substring(0, lastSlash));
}
};
const insertFile = (relativePath, stat, shouldUnpack) => {
insertDirectoryForFile(relativePath);
pendingInserts++;
filesystem.insertFile(relativePath, shouldUnpack, { stat: stat }, {}, onFileInserted);
};
return es.through(function (file) {
if (file.stat.isDirectory()) {
return;
}
if (!file.stat.isFile()) {
throw new Error(`unknown item in stream!`);
}
const shouldUnpack = shouldUnpackFile(file);
insertFile(file.relative, { size: file.contents.length, mode: file.stat.mode }, shouldUnpack);
if (shouldUnpack) {
// The file goes outside of xx.asar, in a folder xx.asar.unpacked
const relative = path.relative(folderPath, file.path);
this.queue(new VinylFile({
cwd: folderPath,
base: folderPath,
path: path.join(destFilename + '.unpacked', relative),
stat: file.stat,
contents: file.contents
}));
}
else {
// The file goes inside of xx.asar
out.push(file.contents);
}
}, function () {
let finish = () => {
{
const headerPickle = pickle.createEmpty();
headerPickle.writeString(JSON.stringify(filesystem.header));
const headerBuf = headerPickle.toBuffer();
const sizePickle = pickle.createEmpty();
sizePickle.writeUInt32(headerBuf.length);
const sizeBuf = sizePickle.toBuffer();
out.unshift(headerBuf);
out.unshift(sizeBuf);
}
const contents = Buffer.concat(out);
out.length = 0;
this.queue(new VinylFile({
cwd: folderPath,
base: folderPath,
path: destFilename,
contents: contents
}));
this.queue(null);
};
// Call finish() only when all file inserts have finished...
if (pendingInserts === 0) {
finish();
}
else {
onFileInserted = () => {
pendingInserts--;
if (pendingInserts === 0) {
finish();
}
};
}
});
}
exports.createAsar = createAsar;
================================================
FILE: build/lib/asar.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as path from 'path';
import * as es from 'event-stream';
const pickle = require('chromium-pickle-js');
const Filesystem = require('asar/lib/filesystem');
import * as VinylFile from 'vinyl';
import * as minimatch from 'minimatch';
export function createAsar(folderPath: string, unpackGlobs: string[], destFilename: string): NodeJS.ReadWriteStream {
const shouldUnpackFile = (file: VinylFile): boolean => {
for (let i = 0; i < unpackGlobs.length; i++) {
if (minimatch(file.relative, unpackGlobs[i])) {
return true;
}
}
return false;
};
const filesystem = new Filesystem(folderPath);
const out: Buffer[] = [];
// Keep track of pending inserts
let pendingInserts = 0;
let onFileInserted = () => { pendingInserts--; };
// Do not insert twice the same directory
const seenDir: { [key: string]: boolean; } = {};
const insertDirectoryRecursive = (dir: string) => {
if (seenDir[dir]) {
return;
}
let lastSlash = dir.lastIndexOf('/');
if (lastSlash === -1) {
lastSlash = dir.lastIndexOf('\\');
}
if (lastSlash !== -1) {
insertDirectoryRecursive(dir.substring(0, lastSlash));
}
seenDir[dir] = true;
filesystem.insertDirectory(dir);
};
const insertDirectoryForFile = (file: string) => {
let lastSlash = file.lastIndexOf('/');
if (lastSlash === -1) {
lastSlash = file.lastIndexOf('\\');
}
if (lastSlash !== -1) {
insertDirectoryRecursive(file.substring(0, lastSlash));
}
};
const insertFile = (relativePath: string, stat: { size: number; mode: number; }, shouldUnpack: boolean) => {
insertDirectoryForFile(relativePath);
pendingInserts++;
filesystem.insertFile(relativePath, shouldUnpack, { stat: stat }, {}, onFileInserted);
};
return es.through(function (file) {
if (file.stat.isDirectory()) {
return;
}
if (!file.stat.isFile()) {
throw new Error(`unknown item in stream!`);
}
const shouldUnpack = shouldUnpackFile(file);
insertFile(file.relative, { size: file.contents.length, mode: file.stat.mode }, shouldUnpack);
if (shouldUnpack) {
// The file goes outside of xx.asar, in a folder xx.asar.unpacked
const relative = path.relative(folderPath, file.path);
this.queue(new VinylFile({
cwd: folderPath,
base: folderPath,
path: path.join(destFilename + '.unpacked', relative),
stat: file.stat,
contents: file.contents
}));
} else {
// The file goes inside of xx.asar
out.push(file.contents);
}
}, function () {
let finish = () => {
{
const headerPickle = pickle.createEmpty();
headerPickle.writeString(JSON.stringify(filesystem.header));
const headerBuf = headerPickle.toBuffer();
const sizePickle = pickle.createEmpty();
sizePickle.writeUInt32(headerBuf.length);
const sizeBuf = sizePickle.toBuffer();
out.unshift(headerBuf);
out.unshift(sizeBuf);
}
const contents = Buffer.concat(out);
out.length = 0;
this.queue(new VinylFile({
cwd: folderPath,
base: folderPath,
path: destFilename,
contents: contents
}));
this.queue(null);
};
// Call finish() only when all file inserts have finished...
if (pendingInserts === 0) {
finish();
} else {
onFileInserted = () => {
pendingInserts--;
if (pendingInserts === 0) {
finish();
}
};
}
});
}
================================================
FILE: build/lib/builtInExtensions.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
const fs = require('fs');
const path = require('path');
const os = require('os');
const mkdirp = require('mkdirp');
const rimraf = require('rimraf');
const es = require('event-stream');
const rename = require('gulp-rename');
const vfs = require('vinyl-fs');
const ext = require('./extensions');
const fancyLog = require('fancy-log');
const ansiColors = require('ansi-colors');
const root = path.dirname(path.dirname(__dirname));
const builtInExtensions = require('../builtInExtensions.json');
const controlFilePath = path.join(os.homedir(), '.vscode-oss-dev', 'extensions', 'control.json');
function getExtensionPath(extension) {
return path.join(root, '.build', 'builtInExtensions', extension.name);
}
function isUpToDate(extension) {
const packagePath = path.join(getExtensionPath(extension), 'package.json');
if (!fs.existsSync(packagePath)) {
return false;
}
const packageContents = fs.readFileSync(packagePath, { encoding: 'utf8' });
try {
const diskVersion = JSON.parse(packageContents).version;
return (diskVersion === extension.version);
} catch (err) {
return false;
}
}
function syncMarketplaceExtension(extension) {
if (isUpToDate(extension)) {
fancyLog(ansiColors.blue('[marketplace]'), `${extension.name}@${extension.version}`, ansiColors.green('✔︎'));
return es.readArray([]);
}
rimraf.sync(getExtensionPath(extension));
return ext.fromMarketplace(extension.name, extension.version, extension.metadata)
.pipe(rename(p => p.dirname = `${extension.name}/${p.dirname}`))
.pipe(vfs.dest('.build/builtInExtensions'))
.on('end', () => fancyLog(ansiColors.blue('[marketplace]'), extension.name, ansiColors.green('✔︎')));
}
function syncExtension(extension, controlState) {
switch (controlState) {
case 'disabled':
fancyLog(ansiColors.blue('[disabled]'), ansiColors.gray(extension.name));
return es.readArray([]);
case 'marketplace':
return syncMarketplaceExtension(extension);
default:
if (!fs.existsSync(controlState)) {
fancyLog(ansiColors.red(`Error: Built-in extension '${extension.name}' is configured to run from '${controlState}' but that path does not exist.`));
return es.readArray([]);
} else if (!fs.existsSync(path.join(controlState, 'package.json'))) {
fancyLog(ansiColors.red(`Error: Built-in extension '${extension.name}' is configured to run from '${controlState}' but there is no 'package.json' file in that directory.`));
return es.readArray([]);
}
fancyLog(ansiColors.blue('[local]'), `${extension.name}: ${ansiColors.cyan(controlState)}`, ansiColors.green('✔︎'));
return es.readArray([]);
}
}
function readControlFile() {
try {
return JSON.parse(fs.readFileSync(controlFilePath, 'utf8'));
} catch (err) {
return {};
}
}
function writeControlFile(control) {
mkdirp.sync(path.dirname(controlFilePath));
fs.writeFileSync(controlFilePath, JSON.stringify(control, null, 2));
}
function main() {
fancyLog('Syncronizing built-in extensions...');
fancyLog(`You can manage built-in extensions with the ${ansiColors.cyan('--builtin')} flag`);
const control = readControlFile();
const streams = [];
for (const extension of builtInExtensions) {
let controlState = control[extension.name] || 'marketplace';
control[extension.name] = controlState;
streams.push(syncExtension(extension, controlState));
}
writeControlFile(control);
es.merge(streams)
.on('error', err => {
console.error(err);
process.exit(1);
})
.on('end', () => {
process.exit(0);
});
}
main();
================================================
FILE: build/lib/bundle.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const path = require("path");
const vm = require("vm");
/**
* Bundle `entryPoints` given config `config`.
*/
function bundle(entryPoints, config, callback) {
const entryPointsMap = {};
entryPoints.forEach((module) => {
entryPointsMap[module.name] = module;
});
const allMentionedModulesMap = {};
entryPoints.forEach((module) => {
allMentionedModulesMap[module.name] = true;
(module.include || []).forEach(function (includedModule) {
allMentionedModulesMap[includedModule] = true;
});
(module.exclude || []).forEach(function (excludedModule) {
allMentionedModulesMap[excludedModule] = true;
});
});
const code = require('fs').readFileSync(path.join(__dirname, '../../src/vs/loader.js'));
const r = vm.runInThisContext('(function(require, module, exports) { ' + code + '\n});');
const loaderModule = { exports: {} };
r.call({}, require, loaderModule, loaderModule.exports);
const loader = loaderModule.exports;
config.isBuild = true;
config.paths = config.paths || {};
if (!config.paths['vs/nls']) {
config.paths['vs/nls'] = 'out-build/vs/nls.build';
}
if (!config.paths['vs/css']) {
config.paths['vs/css'] = 'out-build/vs/css.build';
}
loader.config(config);
loader(['require'], (localRequire) => {
const resolvePath = (path) => {
const r = localRequire.toUrl(path);
if (!/\.js/.test(r)) {
return r + '.js';
}
return r;
};
for (const moduleId in entryPointsMap) {
const entryPoint = entryPointsMap[moduleId];
if (entryPoint.append) {
entryPoint.append = entryPoint.append.map(resolvePath);
}
if (entryPoint.prepend) {
entryPoint.prepend = entryPoint.prepend.map(resolvePath);
}
}
});
loader(Object.keys(allMentionedModulesMap), () => {
const modules = loader.getBuildInfo();
const partialResult = emitEntryPoints(modules, entryPointsMap);
const cssInlinedResources = loader('vs/css').getInlinedResources();
callback(null, {
files: partialResult.files,
cssInlinedResources: cssInlinedResources,
bundleData: partialResult.bundleData
});
}, (err) => callback(err, null));
}
exports.bundle = bundle;
function emitEntryPoints(modules, entryPoints) {
const modulesMap = {};
modules.forEach((m) => {
modulesMap[m.id] = m;
});
const modulesGraph = {};
modules.forEach((m) => {
modulesGraph[m.id] = m.dependencies;
});
const sortedModules = topologicalSort(modulesGraph);
let result = [];
const usedPlugins = {};
const bundleData = {
graph: modulesGraph,
bundles: {}
};
Object.keys(entryPoints).forEach((moduleToBundle) => {
const info = entryPoints[moduleToBundle];
const rootNodes = [moduleToBundle].concat(info.include || []);
const allDependencies = visit(rootNodes, modulesGraph);
const excludes = ['require', 'exports', 'module'].concat(info.exclude || []);
excludes.forEach((excludeRoot) => {
const allExcludes = visit([excludeRoot], modulesGraph);
Object.keys(allExcludes).forEach((exclude) => {
delete allDependencies[exclude];
});
});
const includedModules = sortedModules.filter((module) => {
return allDependencies[module];
});
bundleData.bundles[moduleToBundle] = includedModules;
const res = emitEntryPoint(modulesMap, modulesGraph, moduleToBundle, includedModules, info.prepend || [], info.append || [], info.dest);
result = result.concat(res.files);
for (const pluginName in res.usedPlugins) {
usedPlugins[pluginName] = usedPlugins[pluginName] || res.usedPlugins[pluginName];
}
});
Object.keys(usedPlugins).forEach((pluginName) => {
const plugin = usedPlugins[pluginName];
if (typeof plugin.finishBuild === 'function') {
const write = (filename, contents) => {
result.push({
dest: filename,
sources: [{
path: null,
contents: contents
}]
});
};
plugin.finishBuild(write);
}
});
return {
// TODO@TS 2.1.2
files: extractStrings(removeDuplicateTSBoilerplate(result)),
bundleData: bundleData
};
}
function extractStrings(destFiles) {
const parseDefineCall = (moduleMatch, depsMatch) => {
const module = moduleMatch.replace(/^"|"$/g, '');
let deps = depsMatch.split(',');
deps = deps.map((dep) => {
dep = dep.trim();
dep = dep.replace(/^"|"$/g, '');
dep = dep.replace(/^'|'$/g, '');
let prefix = null;
let _path = null;
const pieces = dep.split('!');
if (pieces.length > 1) {
prefix = pieces[0] + '!';
_path = pieces[1];
}
else {
prefix = '';
_path = pieces[0];
}
if (/^\.\//.test(_path) || /^\.\.\//.test(_path)) {
const res = path.join(path.dirname(module), _path).replace(/\\/g, '/');
return prefix + res;
}
return prefix + _path;
});
return {
module: module,
deps: deps
};
};
destFiles.forEach((destFile) => {
if (!/\.js$/.test(destFile.dest)) {
return;
}
if (/\.nls\.js$/.test(destFile.dest)) {
return;
}
// Do one pass to record the usage counts for each module id
const useCounts = {};
destFile.sources.forEach((source) => {
const matches = source.contents.match(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/);
if (!matches) {
return;
}
const defineCall = parseDefineCall(matches[1], matches[2]);
useCounts[defineCall.module] = (useCounts[defineCall.module] || 0) + 1;
defineCall.deps.forEach((dep) => {
useCounts[dep] = (useCounts[dep] || 0) + 1;
});
});
const sortedByUseModules = Object.keys(useCounts);
sortedByUseModules.sort((a, b) => {
return useCounts[b] - useCounts[a];
});
const replacementMap = {};
sortedByUseModules.forEach((module, index) => {
replacementMap[module] = index;
});
destFile.sources.forEach((source) => {
source.contents = source.contents.replace(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/, (_, moduleMatch, depsMatch) => {
const defineCall = parseDefineCall(moduleMatch, depsMatch);
return `define(__m[${replacementMap[defineCall.module]}/*${defineCall.module}*/], __M([${defineCall.deps.map(dep => replacementMap[dep] + '/*' + dep + '*/').join(',')}])`;
});
});
destFile.sources.unshift({
path: null,
contents: [
'(function() {',
`var __m = ${JSON.stringify(sortedByUseModules)};`,
`var __M = function(deps) {`,
` var result = [];`,
` for (var i = 0, len = deps.length; i < len; i++) {`,
` result[i] = __m[deps[i]];`,
` }`,
` return result;`,
`};`
].join('\n')
});
destFile.sources.push({
path: null,
contents: '}).call(this);'
});
});
return destFiles;
}
function removeDuplicateTSBoilerplate(destFiles) {
// Taken from typescript compiler => emitFiles
const BOILERPLATE = [
{ start: /^var __extends/, end: /^}\)\(\);$/ },
{ start: /^var __assign/, end: /^};$/ },
{ start: /^var __decorate/, end: /^};$/ },
{ start: /^var __metadata/, end: /^};$/ },
{ start: /^var __param/, end: /^};$/ },
{ start: /^var __awaiter/, end: /^};$/ },
{ start: /^var __generator/, end: /^};$/ },
];
destFiles.forEach((destFile) => {
const SEEN_BOILERPLATE = [];
destFile.sources.forEach((source) => {
const lines = source.contents.split(/\r\n|\n|\r/);
const newLines = [];
let IS_REMOVING_BOILERPLATE = false, END_BOILERPLATE;
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (IS_REMOVING_BOILERPLATE) {
newLines.push('');
if (END_BOILERPLATE.test(line)) {
IS_REMOVING_BOILERPLATE = false;
}
}
else {
for (let j = 0; j < BOILERPLATE.length; j++) {
const boilerplate = BOILERPLATE[j];
if (boilerplate.start.test(line)) {
if (SEEN_BOILERPLATE[j]) {
IS_REMOVING_BOILERPLATE = true;
END_BOILERPLATE = boilerplate.end;
}
else {
SEEN_BOILERPLATE[j] = true;
}
}
}
if (IS_REMOVING_BOILERPLATE) {
newLines.push('');
}
else {
newLines.push(line);
}
}
}
source.contents = newLines.join('\n');
});
});
return destFiles;
}
function emitEntryPoint(modulesMap, deps, entryPoint, includedModules, prepend, append, dest) {
if (!dest) {
dest = entryPoint + '.js';
}
const mainResult = {
sources: [],
dest: dest
}, results = [mainResult];
const usedPlugins = {};
const getLoaderPlugin = (pluginName) => {
if (!usedPlugins[pluginName]) {
usedPlugins[pluginName] = modulesMap[pluginName].exports;
}
return usedPlugins[pluginName];
};
includedModules.forEach((c) => {
const bangIndex = c.indexOf('!');
if (bangIndex >= 0) {
const pluginName = c.substr(0, bangIndex);
const plugin = getLoaderPlugin(pluginName);
mainResult.sources.push(emitPlugin(entryPoint, plugin, pluginName, c.substr(bangIndex + 1)));
return;
}
const module = modulesMap[c];
if (module.path === 'empty:') {
return;
}
const contents = readFileAndRemoveBOM(module.path);
if (module.shim) {
mainResult.sources.push(emitShimmedModule(c, deps[c], module.shim, module.path, contents));
}
else {
mainResult.sources.push(emitNamedModule(c, module.defineLocation, module.path, contents));
}
});
Object.keys(usedPlugins).forEach((pluginName) => {
const plugin = usedPlugins[pluginName];
if (typeof plugin.writeFile === 'function') {
const req = (() => {
throw new Error('no-no!');
});
req.toUrl = something => something;
const write = (filename, contents) => {
results.push({
dest: filename,
sources: [{
path: null,
contents: contents
}]
});
};
plugin.writeFile(pluginName, entryPoint, req, write, {});
}
});
const toIFile = (path) => {
const contents = readFileAndRemoveBOM(path);
return {
path: path,
contents: contents
};
};
const toPrepend = (prepend || []).map(toIFile);
const toAppend = (append || []).map(toIFile);
mainResult.sources = toPrepend.concat(mainResult.sources).concat(toAppend);
return {
files: results,
usedPlugins: usedPlugins
};
}
function readFileAndRemoveBOM(path) {
const BOM_CHAR_CODE = 65279;
let contents = fs.readFileSync(path, 'utf8');
// Remove BOM
if (contents.charCodeAt(0) === BOM_CHAR_CODE) {
contents = contents.substring(1);
}
return contents;
}
function emitPlugin(entryPoint, plugin, pluginName, moduleName) {
let result = '';
if (typeof plugin.write === 'function') {
const write = ((what) => {
result += what;
});
write.getEntryPoint = () => {
return entryPoint;
};
write.asModule = (moduleId, code) => {
code = code.replace(/^define\(/, 'define("' + moduleId + '",');
result += code;
};
plugin.write(pluginName, moduleName, write);
}
return {
path: null,
contents: result
};
}
function emitNamedModule(moduleId, defineCallPosition, path, contents) {
// `defineCallPosition` is the position in code: |define()
const defineCallOffset = positionToOffset(contents, defineCallPosition.line, defineCallPosition.col);
// `parensOffset` is the position in code: define|()
const parensOffset = contents.indexOf('(', defineCallOffset);
const insertStr = '"' + moduleId + '", ';
return {
path: path,
contents: contents.substr(0, parensOffset + 1) + insertStr + contents.substr(parensOffset + 1)
};
}
function emitShimmedModule(moduleId, myDeps, factory, path, contents) {
const strDeps = (myDeps.length > 0 ? '"' + myDeps.join('", "') + '"' : '');
const strDefine = 'define("' + moduleId + '", [' + strDeps + '], ' + factory + ');';
return {
path: path,
contents: contents + '\n;\n' + strDefine
};
}
/**
* Convert a position (line:col) to (offset) in string `str`
*/
function positionToOffset(str, desiredLine, desiredCol) {
if (desiredLine === 1) {
return desiredCol - 1;
}
let line = 1;
let lastNewLineOffset = -1;
do {
if (desiredLine === line) {
return lastNewLineOffset + 1 + desiredCol - 1;
}
lastNewLineOffset = str.indexOf('\n', lastNewLineOffset + 1);
line++;
} while (lastNewLineOffset >= 0);
return -1;
}
/**
* Return a set of reachable nodes in `graph` starting from `rootNodes`
*/
function visit(rootNodes, graph) {
const result = {};
const queue = rootNodes;
rootNodes.forEach((node) => {
result[node] = true;
});
while (queue.length > 0) {
const el = queue.shift();
const myEdges = graph[el] || [];
myEdges.forEach((toNode) => {
if (!result[toNode]) {
result[toNode] = true;
queue.push(toNode);
}
});
}
return result;
}
/**
* Perform a topological sort on `graph`
*/
function topologicalSort(graph) {
const allNodes = {}, outgoingEdgeCount = {}, inverseEdges = {};
Object.keys(graph).forEach((fromNode) => {
allNodes[fromNode] = true;
outgoingEdgeCount[fromNode] = graph[fromNode].length;
graph[fromNode].forEach((toNode) => {
allNodes[toNode] = true;
outgoingEdgeCount[toNode] = outgoingEdgeCount[toNode] || 0;
inverseEdges[toNode] = inverseEdges[toNode] || [];
inverseEdges[toNode].push(fromNode);
});
});
// https://en.wikipedia.org/wiki/Topological_sorting
const S = [], L = [];
Object.keys(allNodes).forEach((node) => {
if (outgoingEdgeCount[node] === 0) {
delete outgoingEdgeCount[node];
S.push(node);
}
});
while (S.length > 0) {
// Ensure the exact same order all the time with the same inputs
S.sort();
const n = S.shift();
L.push(n);
const myInverseEdges = inverseEdges[n] || [];
myInverseEdges.forEach((m) => {
outgoingEdgeCount[m]--;
if (outgoingEdgeCount[m] === 0) {
delete outgoingEdgeCount[m];
S.push(m);
}
});
}
if (Object.keys(outgoingEdgeCount).length > 0) {
throw new Error('Cannot do topological sort on cyclic graph, remaining nodes: ' + Object.keys(outgoingEdgeCount));
}
return L;
}
================================================
FILE: build/lib/bundle.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as fs from 'fs';
import * as path from 'path';
import * as vm from 'vm';
interface IPosition {
line: number;
col: number;
}
interface IBuildModuleInfo {
id: string;
path: string;
defineLocation: IPosition;
dependencies: string[];
shim: string;
exports: any;
}
interface IBuildModuleInfoMap {
[moduleId: string]: IBuildModuleInfo;
}
interface ILoaderPlugin {
write(pluginName: string, moduleName: string, write: ILoaderPluginWriteFunc): void;
writeFile(pluginName: string, entryPoint: string, req: ILoaderPluginReqFunc, write: (filename: string, contents: string) => void, config: any): void;
finishBuild(write: (filename: string, contents: string) => void): void;
}
interface ILoaderPluginWriteFunc {
(something: string): void;
getEntryPoint(): string;
asModule(moduleId: string, code: string): void;
}
interface ILoaderPluginReqFunc {
(something: string): void;
toUrl(something: string): string;
}
export interface IEntryPoint {
name: string;
include?: string[];
exclude?: string[];
prepend?: string[];
append?: string[];
dest?: string;
}
interface IEntryPointMap {
[moduleId: string]: IEntryPoint;
}
export interface IGraph {
[node: string]: string[];
}
interface INodeSet {
[node: string]: boolean;
}
export interface IFile {
path: string | null;
contents: string;
}
export interface IConcatFile {
dest: string;
sources: IFile[];
}
export interface IBundleData {
graph: IGraph;
bundles: { [moduleId: string]: string[]; };
}
export interface IBundleResult {
files: IConcatFile[];
cssInlinedResources: string[];
bundleData: IBundleData;
}
interface IPartialBundleResult {
files: IConcatFile[];
bundleData: IBundleData;
}
export interface ILoaderConfig {
isBuild?: boolean;
paths?: { [path: string]: any; };
}
/**
* Bundle `entryPoints` given config `config`.
*/
export function bundle(entryPoints: IEntryPoint[], config: ILoaderConfig, callback: (err: any, result: IBundleResult | null) => void): void {
const entryPointsMap: IEntryPointMap = {};
entryPoints.forEach((module: IEntryPoint) => {
entryPointsMap[module.name] = module;
});
const allMentionedModulesMap: { [modules: string]: boolean; } = {};
entryPoints.forEach((module: IEntryPoint) => {
allMentionedModulesMap[module.name] = true;
(module.include || []).forEach(function (includedModule) {
allMentionedModulesMap[includedModule] = true;
});
(module.exclude || []).forEach(function (excludedModule) {
allMentionedModulesMap[excludedModule] = true;
});
});
const code = require('fs').readFileSync(path.join(__dirname, '../../src/vs/loader.js'));
const r: Function = vm.runInThisContext('(function(require, module, exports) { ' + code + '\n});');
const loaderModule = { exports: {} };
r.call({}, require, loaderModule, loaderModule.exports);
const loader: any = loaderModule.exports;
config.isBuild = true;
config.paths = config.paths || {};
if (!config.paths['vs/nls']) {
config.paths['vs/nls'] = 'out-build/vs/nls.build';
}
if (!config.paths['vs/css']) {
config.paths['vs/css'] = 'out-build/vs/css.build';
}
loader.config(config);
loader(['require'], (localRequire: any) => {
const resolvePath = (path: string) => {
const r = localRequire.toUrl(path);
if (!/\.js/.test(r)) {
return r + '.js';
}
return r;
};
for (const moduleId in entryPointsMap) {
const entryPoint = entryPointsMap[moduleId];
if (entryPoint.append) {
entryPoint.append = entryPoint.append.map(resolvePath);
}
if (entryPoint.prepend) {
entryPoint.prepend = entryPoint.prepend.map(resolvePath);
}
}
});
loader(Object.keys(allMentionedModulesMap), () => {
const modules = loader.getBuildInfo();
const partialResult = emitEntryPoints(modules, entryPointsMap);
const cssInlinedResources = loader('vs/css').getInlinedResources();
callback(null, {
files: partialResult.files,
cssInlinedResources: cssInlinedResources,
bundleData: partialResult.bundleData
});
}, (err: any) => callback(err, null));
}
function emitEntryPoints(modules: IBuildModuleInfo[], entryPoints: IEntryPointMap): IPartialBundleResult {
const modulesMap: IBuildModuleInfoMap = {};
modules.forEach((m: IBuildModuleInfo) => {
modulesMap[m.id] = m;
});
const modulesGraph: IGraph = {};
modules.forEach((m: IBuildModuleInfo) => {
modulesGraph[m.id] = m.dependencies;
});
const sortedModules = topologicalSort(modulesGraph);
let result: IConcatFile[] = [];
const usedPlugins: IPluginMap = {};
const bundleData: IBundleData = {
graph: modulesGraph,
bundles: {}
};
Object.keys(entryPoints).forEach((moduleToBundle: string) => {
const info = entryPoints[moduleToBundle];
const rootNodes = [moduleToBundle].concat(info.include || []);
const allDependencies = visit(rootNodes, modulesGraph);
const excludes: string[] = ['require', 'exports', 'module'].concat(info.exclude || []);
excludes.forEach((excludeRoot: string) => {
const allExcludes = visit([excludeRoot], modulesGraph);
Object.keys(allExcludes).forEach((exclude: string) => {
delete allDependencies[exclude];
});
});
const includedModules = sortedModules.filter((module: string) => {
return allDependencies[module];
});
bundleData.bundles[moduleToBundle] = includedModules;
const res = emitEntryPoint(
modulesMap,
modulesGraph,
moduleToBundle,
includedModules,
info.prepend || [],
info.append || [],
info.dest
);
result = result.concat(res.files);
for (const pluginName in res.usedPlugins) {
usedPlugins[pluginName] = usedPlugins[pluginName] || res.usedPlugins[pluginName];
}
});
Object.keys(usedPlugins).forEach((pluginName: string) => {
const plugin = usedPlugins[pluginName];
if (typeof plugin.finishBuild === 'function') {
const write = (filename: string, contents: string) => {
result.push({
dest: filename,
sources: [{
path: null,
contents: contents
}]
});
};
plugin.finishBuild(write);
}
});
return {
// TODO@TS 2.1.2
files: extractStrings(removeDuplicateTSBoilerplate(result)),
bundleData: bundleData
};
}
function extractStrings(destFiles: IConcatFile[]): IConcatFile[] {
const parseDefineCall = (moduleMatch: string, depsMatch: string) => {
const module = moduleMatch.replace(/^"|"$/g, '');
let deps = depsMatch.split(',');
deps = deps.map((dep) => {
dep = dep.trim();
dep = dep.replace(/^"|"$/g, '');
dep = dep.replace(/^'|'$/g, '');
let prefix: string | null = null;
let _path: string | null = null;
const pieces = dep.split('!');
if (pieces.length > 1) {
prefix = pieces[0] + '!';
_path = pieces[1];
} else {
prefix = '';
_path = pieces[0];
}
if (/^\.\//.test(_path) || /^\.\.\//.test(_path)) {
const res = path.join(path.dirname(module), _path).replace(/\\/g, '/');
return prefix + res;
}
return prefix + _path;
});
return {
module: module,
deps: deps
};
};
destFiles.forEach((destFile) => {
if (!/\.js$/.test(destFile.dest)) {
return;
}
if (/\.nls\.js$/.test(destFile.dest)) {
return;
}
// Do one pass to record the usage counts for each module id
const useCounts: { [moduleId: string]: number; } = {};
destFile.sources.forEach((source) => {
const matches = source.contents.match(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/);
if (!matches) {
return;
}
const defineCall = parseDefineCall(matches[1], matches[2]);
useCounts[defineCall.module] = (useCounts[defineCall.module] || 0) + 1;
defineCall.deps.forEach((dep) => {
useCounts[dep] = (useCounts[dep] || 0) + 1;
});
});
const sortedByUseModules = Object.keys(useCounts);
sortedByUseModules.sort((a, b) => {
return useCounts[b] - useCounts[a];
});
const replacementMap: { [moduleId: string]: number; } = {};
sortedByUseModules.forEach((module, index) => {
replacementMap[module] = index;
});
destFile.sources.forEach((source) => {
source.contents = source.contents.replace(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/, (_, moduleMatch, depsMatch) => {
const defineCall = parseDefineCall(moduleMatch, depsMatch);
return `define(__m[${replacementMap[defineCall.module]}/*${defineCall.module}*/], __M([${defineCall.deps.map(dep => replacementMap[dep] + '/*' + dep + '*/').join(',')}])`;
});
});
destFile.sources.unshift({
path: null,
contents: [
'(function() {',
`var __m = ${JSON.stringify(sortedByUseModules)};`,
`var __M = function(deps) {`,
` var result = [];`,
` for (var i = 0, len = deps.length; i < len; i++) {`,
` result[i] = __m[deps[i]];`,
` }`,
` return result;`,
`};`
].join('\n')
});
destFile.sources.push({
path: null,
contents: '}).call(this);'
});
});
return destFiles;
}
function removeDuplicateTSBoilerplate(destFiles: IConcatFile[]): IConcatFile[] {
// Taken from typescript compiler => emitFiles
const BOILERPLATE = [
{ start: /^var __extends/, end: /^}\)\(\);$/ },
{ start: /^var __assign/, end: /^};$/ },
{ start: /^var __decorate/, end: /^};$/ },
{ start: /^var __metadata/, end: /^};$/ },
{ start: /^var __param/, end: /^};$/ },
{ start: /^var __awaiter/, end: /^};$/ },
{ start: /^var __generator/, end: /^};$/ },
];
destFiles.forEach((destFile) => {
const SEEN_BOILERPLATE: boolean[] = [];
destFile.sources.forEach((source) => {
const lines = source.contents.split(/\r\n|\n|\r/);
const newLines: string[] = [];
let IS_REMOVING_BOILERPLATE = false, END_BOILERPLATE: RegExp;
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (IS_REMOVING_BOILERPLATE) {
newLines.push('');
if (END_BOILERPLATE!.test(line)) {
IS_REMOVING_BOILERPLATE = false;
}
} else {
for (let j = 0; j < BOILERPLATE.length; j++) {
const boilerplate = BOILERPLATE[j];
if (boilerplate.start.test(line)) {
if (SEEN_BOILERPLATE[j]) {
IS_REMOVING_BOILERPLATE = true;
END_BOILERPLATE = boilerplate.end;
} else {
SEEN_BOILERPLATE[j] = true;
}
}
}
if (IS_REMOVING_BOILERPLATE) {
newLines.push('');
} else {
newLines.push(line);
}
}
}
source.contents = newLines.join('\n');
});
});
return destFiles;
}
interface IPluginMap {
[moduleId: string]: ILoaderPlugin;
}
interface IEmitEntryPointResult {
files: IConcatFile[];
usedPlugins: IPluginMap;
}
function emitEntryPoint(
modulesMap: IBuildModuleInfoMap,
deps: IGraph,
entryPoint: string,
includedModules: string[],
prepend: string[],
append: string[],
dest: string | undefined
): IEmitEntryPointResult {
if (!dest) {
dest = entryPoint + '.js';
}
const mainResult: IConcatFile = {
sources: [],
dest: dest
},
results: IConcatFile[] = [mainResult];
const usedPlugins: IPluginMap = {};
const getLoaderPlugin = (pluginName: string): ILoaderPlugin => {
if (!usedPlugins[pluginName]) {
usedPlugins[pluginName] = modulesMap[pluginName].exports;
}
return usedPlugins[pluginName];
};
includedModules.forEach((c: string) => {
const bangIndex = c.indexOf('!');
if (bangIndex >= 0) {
const pluginName = c.substr(0, bangIndex);
const plugin = getLoaderPlugin(pluginName);
mainResult.sources.push(emitPlugin(entryPoint, plugin, pluginName, c.substr(bangIndex + 1)));
return;
}
const module = modulesMap[c];
if (module.path === 'empty:') {
return;
}
const contents = readFileAndRemoveBOM(module.path);
if (module.shim) {
mainResult.sources.push(emitShimmedModule(c, deps[c], module.shim, module.path, contents));
} else {
mainResult.sources.push(emitNamedModule(c, module.defineLocation, module.path, contents));
}
});
Object.keys(usedPlugins).forEach((pluginName: string) => {
const plugin = usedPlugins[pluginName];
if (typeof plugin.writeFile === 'function') {
const req: ILoaderPluginReqFunc = (() => {
throw new Error('no-no!');
});
req.toUrl = something => something;
const write = (filename: string, contents: string) => {
results.push({
dest: filename,
sources: [{
path: null,
contents: contents
}]
});
};
plugin.writeFile(pluginName, entryPoint, req, write, {});
}
});
const toIFile = (path: string): IFile => {
const contents = readFileAndRemoveBOM(path);
return {
path: path,
contents: contents
};
};
const toPrepend = (prepend || []).map(toIFile);
const toAppend = (append || []).map(toIFile);
mainResult.sources = toPrepend.concat(mainResult.sources).concat(toAppend);
return {
files: results,
usedPlugins: usedPlugins
};
}
function readFileAndRemoveBOM(path: string): string {
const BOM_CHAR_CODE = 65279;
let contents = fs.readFileSync(path, 'utf8');
// Remove BOM
if (contents.charCodeAt(0) === BOM_CHAR_CODE) {
contents = contents.substring(1);
}
return contents;
}
function emitPlugin(entryPoint: string, plugin: ILoaderPlugin, pluginName: string, moduleName: string): IFile {
let result = '';
if (typeof plugin.write === 'function') {
const write: ILoaderPluginWriteFunc = ((what: string) => {
result += what;
});
write.getEntryPoint = () => {
return entryPoint;
};
write.asModule = (moduleId: string, code: string) => {
code = code.replace(/^define\(/, 'define("' + moduleId + '",');
result += code;
};
plugin.write(pluginName, moduleName, write);
}
return {
path: null,
contents: result
};
}
function emitNamedModule(moduleId: string, defineCallPosition: IPosition, path: string, contents: string): IFile {
// `defineCallPosition` is the position in code: |define()
const defineCallOffset = positionToOffset(contents, defineCallPosition.line, defineCallPosition.col);
// `parensOffset` is the position in code: define|()
const parensOffset = contents.indexOf('(', defineCallOffset);
const insertStr = '"' + moduleId + '", ';
return {
path: path,
contents: contents.substr(0, parensOffset + 1) + insertStr + contents.substr(parensOffset + 1)
};
}
function emitShimmedModule(moduleId: string, myDeps: string[], factory: string, path: string, contents: string): IFile {
const strDeps = (myDeps.length > 0 ? '"' + myDeps.join('", "') + '"' : '');
const strDefine = 'define("' + moduleId + '", [' + strDeps + '], ' + factory + ');';
return {
path: path,
contents: contents + '\n;\n' + strDefine
};
}
/**
* Convert a position (line:col) to (offset) in string `str`
*/
function positionToOffset(str: string, desiredLine: number, desiredCol: number): number {
if (desiredLine === 1) {
return desiredCol - 1;
}
let line = 1;
let lastNewLineOffset = -1;
do {
if (desiredLine === line) {
return lastNewLineOffset + 1 + desiredCol - 1;
}
lastNewLineOffset = str.indexOf('\n', lastNewLineOffset + 1);
line++;
} while (lastNewLineOffset >= 0);
return -1;
}
/**
* Return a set of reachable nodes in `graph` starting from `rootNodes`
*/
function visit(rootNodes: string[], graph: IGraph): INodeSet {
const result: INodeSet = {};
const queue = rootNodes;
rootNodes.forEach((node) => {
result[node] = true;
});
while (queue.length > 0) {
const el = queue.shift();
const myEdges = graph[el!] || [];
myEdges.forEach((toNode) => {
if (!result[toNode]) {
result[toNode] = true;
queue.push(toNode);
}
});
}
return result;
}
/**
* Perform a topological sort on `graph`
*/
function topologicalSort(graph: IGraph): string[] {
const allNodes: INodeSet = {},
outgoingEdgeCount: { [node: string]: number; } = {},
inverseEdges: IGraph = {};
Object.keys(graph).forEach((fromNode: string) => {
allNodes[fromNode] = true;
outgoingEdgeCount[fromNode] = graph[fromNode].length;
graph[fromNode].forEach((toNode) => {
allNodes[toNode] = true;
outgoingEdgeCount[toNode] = outgoingEdgeCount[toNode] || 0;
inverseEdges[toNode] = inverseEdges[toNode] || [];
inverseEdges[toNode].push(fromNode);
});
});
// https://en.wikipedia.org/wiki/Topological_sorting
const S: string[] = [],
L: string[] = [];
Object.keys(allNodes).forEach((node: string) => {
if (outgoingEdgeCount[node] === 0) {
delete outgoingEdgeCount[node];
S.push(node);
}
});
while (S.length > 0) {
// Ensure the exact same order all the time with the same inputs
S.sort();
const n: string = S.shift()!;
L.push(n);
const myInverseEdges = inverseEdges[n] || [];
myInverseEdges.forEach((m: string) => {
outgoingEdgeCount[m]--;
if (outgoingEdgeCount[m] === 0) {
delete outgoingEdgeCount[m];
S.push(m);
}
});
}
if (Object.keys(outgoingEdgeCount).length > 0) {
throw new Error('Cannot do topological sort on cyclic graph, remaining nodes: ' + Object.keys(outgoingEdgeCount));
}
return L;
}
================================================
FILE: build/lib/compilation.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const es = require("event-stream");
const fs = require("fs");
const gulp = require("gulp");
const bom = require("gulp-bom");
const sourcemaps = require("gulp-sourcemaps");
const tsb = require("gulp-tsb");
const path = require("path");
const monacodts = require("../monaco/api");
const nls = require("./nls");
const reporter_1 = require("./reporter");
const util = require("./util");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const watch = require('./watch');
const reporter = reporter_1.createReporter();
function getTypeScriptCompilerOptions(src) {
const rootDir = path.join(__dirname, `../../${src}`);
let options = {};
options.verbose = false;
options.sourceMap = true;
if (process.env['VSCODE_NO_SOURCEMAP']) { // To be used by developers in a hurry
options.sourceMap = false;
}
options.rootDir = rootDir;
options.baseUrl = rootDir;
options.sourceRoot = util.toFileUri(rootDir);
options.newLine = /\r\n/.test(fs.readFileSync(__filename, 'utf8')) ? 0 : 1;
return options;
}
function createCompile(src, build, emitError) {
const projectPath = path.join(__dirname, '../../', src, 'tsconfig.json');
const overrideOptions = Object.assign(Object.assign({}, getTypeScriptCompilerOptions(src)), { inlineSources: Boolean(build) });
const compilation = tsb.create(projectPath, overrideOptions, false, err => reporter(err));
function pipeline(token) {
const utf8Filter = util.filter(data => /(\/|\\)test(\/|\\).*utf8/.test(data.path));
const tsFilter = util.filter(data => /\.ts$/.test(data.path));
const noDeclarationsFilter = util.filter(data => !(/\.d\.ts$/.test(data.path)));
const input = es.through();
const output = input
.pipe(utf8Filter)
.pipe(bom())
.pipe(utf8Filter.restore)
.pipe(tsFilter)
.pipe(util.loadSourcemaps())
.pipe(compilation(token))
.pipe(noDeclarationsFilter)
.pipe(build ? nls() : es.through())
.pipe(noDeclarationsFilter.restore)
.pipe(sourcemaps.write('.', {
addComment: false,
includeContent: !!build,
sourceRoot: overrideOptions.sourceRoot
}))
.pipe(tsFilter.restore)
.pipe(reporter.end(!!emitError));
return es.duplex(input, output);
}
pipeline.tsProjectSrc = () => {
return compilation.src({ base: src });
};
return pipeline;
}
function compileTask(src, out, build) {
return function () {
const compile = createCompile(src, build, true);
const srcPipe = gulp.src(`${src}/**`, { base: `${src}` });
let generator = new MonacoGenerator(false);
if (src === 'src') {
generator.execute();
}
return srcPipe
.pipe(generator.stream)
.pipe(compile())
.pipe(gulp.dest(out));
};
}
exports.compileTask = compileTask;
function watchTask(out, build) {
return function () {
const compile = createCompile('src', build);
const src = gulp.src('src/**', { base: 'src' });
const watchSrc = watch('src/**', { base: 'src', readDelay: 200 });
let generator = new MonacoGenerator(true);
generator.execute();
return watchSrc
.pipe(generator.stream)
.pipe(util.incremental(compile, src, true))
.pipe(gulp.dest(out));
};
}
exports.watchTask = watchTask;
const REPO_SRC_FOLDER = path.join(__dirname, '../../src');
class MonacoGenerator {
constructor(isWatch) {
this._executeSoonTimer = null;
this._isWatch = isWatch;
this.stream = es.through();
this._watchedFiles = {};
let onWillReadFile = (moduleId, filePath) => {
if (!this._isWatch) {
return;
}
if (this._watchedFiles[filePath]) {
return;
}
this._watchedFiles[filePath] = true;
fs.watchFile(filePath, () => {
this._declarationResolver.invalidateCache(moduleId);
this._executeSoon();
});
};
this._fsProvider = new class extends monacodts.FSProvider {
readFileSync(moduleId, filePath) {
onWillReadFile(moduleId, filePath);
return super.readFileSync(moduleId, filePath);
}
};
this._declarationResolver = new monacodts.DeclarationResolver(this._fsProvider);
if (this._isWatch) {
fs.watchFile(monacodts.RECIPE_PATH, () => {
this._executeSoon();
});
}
}
_executeSoon() {
if (this._executeSoonTimer !== null) {
clearTimeout(this._executeSoonTimer);
this._executeSoonTimer = null;
}
this._executeSoonTimer = setTimeout(() => {
this._executeSoonTimer = null;
this.execute();
}, 20);
}
_run() {
let r = monacodts.run3(this._declarationResolver);
if (!r && !this._isWatch) {
// The build must always be able to generate the monaco.d.ts
throw new Error(`monaco.d.ts generation error - Cannot continue`);
}
return r;
}
_log(message, ...rest) {
fancyLog(ansiColors.cyan('[monaco.d.ts]'), message, ...rest);
}
execute() {
const startTime = Date.now();
const result = this._run();
if (!result) {
// nothing really changed
return;
}
if (result.isTheSame) {
return;
}
fs.writeFileSync(result.filePath, result.content);
fs.writeFileSync(path.join(REPO_SRC_FOLDER, 'vs/editor/common/standalone/standaloneEnums.ts'), result.enums);
this._log(`monaco.d.ts is changed - total time took ${Date.now() - startTime} ms`);
if (!this._isWatch) {
this.stream.emit('error', 'monaco.d.ts is no longer up to date. Please run gulp watch and commit the new file.');
}
}
}
================================================
FILE: build/lib/compilation.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as es from 'event-stream';
import * as fs from 'fs';
import * as gulp from 'gulp';
import * as bom from 'gulp-bom';
import * as sourcemaps from 'gulp-sourcemaps';
import * as tsb from 'gulp-tsb';
import * as path from 'path';
import * as monacodts from '../monaco/api';
import * as nls from './nls';
import { createReporter } from './reporter';
import * as util from './util';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
import ts = require('typescript');
const watch = require('./watch');
const reporter = createReporter();
function getTypeScriptCompilerOptions(src: string): ts.CompilerOptions {
const rootDir = path.join(__dirname, `../../${src}`);
let options: ts.CompilerOptions = {};
options.verbose = false;
options.sourceMap = true;
if (process.env['VSCODE_NO_SOURCEMAP']) { // To be used by developers in a hurry
options.sourceMap = false;
}
options.rootDir = rootDir;
options.baseUrl = rootDir;
options.sourceRoot = util.toFileUri(rootDir);
options.newLine = /\r\n/.test(fs.readFileSync(__filename, 'utf8')) ? 0 : 1;
return options;
}
function createCompile(src: string, build: boolean, emitError?: boolean) {
const projectPath = path.join(__dirname, '../../', src, 'tsconfig.json');
const overrideOptions = { ...getTypeScriptCompilerOptions(src), inlineSources: Boolean(build) };
const compilation = tsb.create(projectPath, overrideOptions, false, err => reporter(err));
function pipeline(token?: util.ICancellationToken) {
const utf8Filter = util.filter(data => /(\/|\\)test(\/|\\).*utf8/.test(data.path));
const tsFilter = util.filter(data => /\.ts$/.test(data.path));
const noDeclarationsFilter = util.filter(data => !(/\.d\.ts$/.test(data.path)));
const input = es.through();
const output = input
.pipe(utf8Filter)
.pipe(bom())
.pipe(utf8Filter.restore)
.pipe(tsFilter)
.pipe(util.loadSourcemaps())
.pipe(compilation(token))
.pipe(noDeclarationsFilter)
.pipe(build ? nls() : es.through())
.pipe(noDeclarationsFilter.restore)
.pipe(sourcemaps.write('.', {
addComment: false,
includeContent: !!build,
sourceRoot: overrideOptions.sourceRoot
}))
.pipe(tsFilter.restore)
.pipe(reporter.end(!!emitError));
return es.duplex(input, output);
}
pipeline.tsProjectSrc = () => {
return compilation.src({ base: src });
};
return pipeline;
}
export function compileTask(src: string, out: string, build: boolean): () => NodeJS.ReadWriteStream {
return function () {
const compile = createCompile(src, build, true);
const srcPipe = gulp.src(`${src}/**`, { base: `${src}` });
let generator = new MonacoGenerator(false);
if (src === 'src') {
generator.execute();
}
return srcPipe
.pipe(generator.stream)
.pipe(compile())
.pipe(gulp.dest(out));
};
}
export function watchTask(out: string, build: boolean): () => NodeJS.ReadWriteStream {
return function () {
const compile = createCompile('src', build);
const src = gulp.src('src/**', { base: 'src' });
const watchSrc = watch('src/**', { base: 'src', readDelay: 200 });
let generator = new MonacoGenerator(true);
generator.execute();
return watchSrc
.pipe(generator.stream)
.pipe(util.incremental(compile, src, true))
.pipe(gulp.dest(out));
};
}
const REPO_SRC_FOLDER = path.join(__dirname, '../../src');
class MonacoGenerator {
private readonly _isWatch: boolean;
public readonly stream: NodeJS.ReadWriteStream;
private readonly _watchedFiles: { [filePath: string]: boolean; };
private readonly _fsProvider: monacodts.FSProvider;
private readonly _declarationResolver: monacodts.DeclarationResolver;
constructor(isWatch: boolean) {
this._isWatch = isWatch;
this.stream = es.through();
this._watchedFiles = {};
let onWillReadFile = (moduleId: string, filePath: string) => {
if (!this._isWatch) {
return;
}
if (this._watchedFiles[filePath]) {
return;
}
this._watchedFiles[filePath] = true;
fs.watchFile(filePath, () => {
this._declarationResolver.invalidateCache(moduleId);
this._executeSoon();
});
};
this._fsProvider = new class extends monacodts.FSProvider {
public readFileSync(moduleId: string, filePath: string): Buffer {
onWillReadFile(moduleId, filePath);
return super.readFileSync(moduleId, filePath);
}
};
this._declarationResolver = new monacodts.DeclarationResolver(this._fsProvider);
if (this._isWatch) {
fs.watchFile(monacodts.RECIPE_PATH, () => {
this._executeSoon();
});
}
}
private _executeSoonTimer: NodeJS.Timer | null = null;
private _executeSoon(): void {
if (this._executeSoonTimer !== null) {
clearTimeout(this._executeSoonTimer);
this._executeSoonTimer = null;
}
this._executeSoonTimer = setTimeout(() => {
this._executeSoonTimer = null;
this.execute();
}, 20);
}
private _run(): monacodts.IMonacoDeclarationResult | null {
let r = monacodts.run3(this._declarationResolver);
if (!r && !this._isWatch) {
// The build must always be able to generate the monaco.d.ts
throw new Error(`monaco.d.ts generation error - Cannot continue`);
}
return r;
}
private _log(message: any, ...rest: any[]): void {
fancyLog(ansiColors.cyan('[monaco.d.ts]'), message, ...rest);
}
public execute(): void {
const startTime = Date.now();
const result = this._run();
if (!result) {
// nothing really changed
return;
}
if (result.isTheSame) {
return;
}
fs.writeFileSync(result.filePath, result.content);
fs.writeFileSync(path.join(REPO_SRC_FOLDER, 'vs/editor/common/standalone/standaloneEnums.ts'), result.enums);
this._log(`monaco.d.ts is changed - total time took ${Date.now() - startTime} ms`);
if (!this._isWatch) {
this.stream.emit('error', 'monaco.d.ts is no longer up to date. Please run gulp watch and commit the new file.');
}
}
}
================================================
FILE: build/lib/electron.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const fs = require("fs");
const path = require("path");
const vfs = require("vinyl-fs");
const filter = require("gulp-filter");
const json = require("gulp-json-editor");
const _ = require("underscore");
const util = require("./util");
const electron = require('gulp-atom-electron');
const root = path.dirname(path.dirname(__dirname));
const product = JSON.parse(fs.readFileSync(path.join(root, 'product.json'), 'utf8'));
const commit = util.getVersion(root);
function getElectronVersion() {
const yarnrc = fs.readFileSync(path.join(root, '.yarnrc'), 'utf8');
const target = /^target "(.*)"$/m.exec(yarnrc)[1];
return target;
}
exports.getElectronVersion = getElectronVersion;
const darwinCreditsTemplate = product.darwinCredits && _.template(fs.readFileSync(path.join(root, product.darwinCredits), 'utf8'));
function darwinBundleDocumentType(extensions, icon) {
return {
name: product.nameLong + ' document',
role: 'Editor',
ostypes: ["TEXT", "utxt", "TUTX", "****"],
extensions: extensions,
iconFile: icon
};
}
exports.config = {
version: getElectronVersion(),
productAppName: product.nameLong,
companyName: 'Microsoft Corporation',
copyright: 'Copyright (C) 2019 Microsoft. All rights reserved',
darwinIcon: 'resources/darwin/code.icns',
darwinBundleIdentifier: product.darwinBundleIdentifier,
darwinApplicationCategoryType: 'public.app-category.developer-tools',
darwinHelpBookFolder: 'VS Code HelpBook',
darwinHelpBookName: 'VS Code HelpBook',
darwinBundleDocumentTypes: [
darwinBundleDocumentType(["bat", "cmd"], 'resources/darwin/bat.icns'),
darwinBundleDocumentType(["bowerrc"], 'resources/darwin/bower.icns'),
darwinBundleDocumentType(["c", "h"], 'resources/darwin/c.icns'),
darwinBundleDocumentType(["config", "editorconfig", "gitattributes", "gitconfig", "gitignore", "ini"], 'resources/darwin/config.icns'),
darwinBundleDocumentType(["cc", "cpp", "cxx", "hh", "hpp", "hxx"], 'resources/darwin/cpp.icns'),
darwinBundleDocumentType(["cs", "csx"], 'resources/darwin/csharp.icns'),
darwinBundleDocumentType(["css"], 'resources/darwin/css.icns'),
darwinBundleDocumentType(["go"], 'resources/darwin/go.icns'),
darwinBundleDocumentType(["asp", "aspx", "cshtml", "htm", "html", "jshtm", "jsp", "phtml", "shtml"], 'resources/darwin/html.icns'),
darwinBundleDocumentType(["jade"], 'resources/darwin/jade.icns'),
darwinBundleDocumentType(["jav", "java"], 'resources/darwin/java.icns'),
darwinBundleDocumentType(["js", "jscsrc", "jshintrc", "mjs"], 'resources/darwin/javascript.icns'),
darwinBundleDocumentType(["json"], 'resources/darwin/json.icns'),
darwinBundleDocumentType(["less"], 'resources/darwin/less.icns'),
darwinBundleDocumentType(["markdown", "md", "mdoc", "mdown", "mdtext", "mdtxt", "mdwn", "mkd", "mkdn"], 'resources/darwin/markdown.icns'),
darwinBundleDocumentType(["php"], 'resources/darwin/php.icns'),
darwinBundleDocumentType(["ps1", "psd1", "psm1"], 'resources/darwin/powershell.icns'),
darwinBundleDocumentType(["py"], 'resources/darwin/python.icns'),
darwinBundleDocumentType(["gemspec", "rb"], 'resources/darwin/ruby.icns'),
darwinBundleDocumentType(["scss"], 'resources/darwin/sass.icns'),
darwinBundleDocumentType(["bash", "bash_login", "bash_logout", "bash_profile", "bashrc", "profile", "rhistory", "rprofile", "sh", "zlogin", "zlogout", "zprofile", "zsh", "zshenv", "zshrc"], 'resources/darwin/shell.icns'),
darwinBundleDocumentType(["sql"], 'resources/darwin/sql.icns'),
darwinBundleDocumentType(["ts"], 'resources/darwin/typescript.icns'),
darwinBundleDocumentType(["tsx", "jsx"], 'resources/darwin/react.icns'),
darwinBundleDocumentType(["vue"], 'resources/darwin/vue.icns'),
darwinBundleDocumentType(["ascx", "csproj", "dtd", "wxi", "wxl", "wxs", "xml", "xaml"], 'resources/darwin/xml.icns'),
darwinBundleDocumentType(["eyaml", "eyml", "yaml", "yml"], 'resources/darwin/yaml.icns'),
darwinBundleDocumentType(["clj", "cljs", "cljx", "clojure", "code-workspace", "coffee", "ctp", "dockerfile", "dot", "edn", "fs", "fsi", "fsscript", "fsx", "handlebars", "hbs", "lua", "m", "makefile", "ml", "mli", "pl", "pl6", "pm", "pm6", "pod", "pp", "properties", "psgi", "pug", "r", "rs", "rt", "svg", "svgz", "t", "txt", "vb", "xcodeproj", "xcworkspace"], 'resources/darwin/default.icns')
],
darwinBundleURLTypes: [{
role: 'Viewer',
name: product.nameLong,
urlSchemes: [product.urlProtocol]
}],
darwinForceDarkModeSupport: true,
darwinCredits: darwinCreditsTemplate ? Buffer.from(darwinCreditsTemplate({ commit: commit, date: new Date().toISOString() })) : undefined,
linuxExecutableName: product.applicationName,
winIcon: 'resources/win32/code.ico',
token: process.env['VSCODE_MIXIN_PASSWORD'] || process.env['GITHUB_TOKEN'] || undefined,
repo: product.electronRepository || undefined
};
function getElectron(arch) {
return () => {
const electronOpts = _.extend({}, exports.config, {
platform: process.platform,
arch,
ffmpegChromium: true,
keepDefaultApp: true
});
return vfs.src('package.json')
.pipe(json({ name: product.nameShort }))
.pipe(electron(electronOpts))
.pipe(filter(['**', '!**/app/package.json']))
.pipe(vfs.dest('.build/electron'));
};
}
async function main(arch = process.arch) {
const version = getElectronVersion();
const electronPath = path.join(root, '.build', 'electron');
const versionFile = path.join(electronPath, 'version');
const isUpToDate = fs.existsSync(versionFile) && fs.readFileSync(versionFile, 'utf8') === `${version}`;
if (!isUpToDate) {
await util.rimraf(electronPath)();
await util.streamToPromise(getElectron(arch)());
}
}
if (require.main === module) {
main(process.argv[2]).catch(err => {
console.error(err);
process.exit(1);
});
}
================================================
FILE: build/lib/electron.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as fs from 'fs';
import * as path from 'path';
import * as vfs from 'vinyl-fs';
import * as filter from 'gulp-filter';
import * as json from 'gulp-json-editor';
import * as _ from 'underscore';
import * as util from './util';
const electron = require('gulp-atom-electron');
const root = path.dirname(path.dirname(__dirname));
const product = JSON.parse(fs.readFileSync(path.join(root, 'product.json'), 'utf8'));
const commit = util.getVersion(root);
export function getElectronVersion(): string {
const yarnrc = fs.readFileSync(path.join(root, '.yarnrc'), 'utf8');
const target = /^target "(.*)"$/m.exec(yarnrc)![1];
return target;
}
const darwinCreditsTemplate = product.darwinCredits && _.template(fs.readFileSync(path.join(root, product.darwinCredits), 'utf8'));
function darwinBundleDocumentType(extensions: string[], icon: string) {
return {
name: product.nameLong + ' document',
role: 'Editor',
ostypes: ["TEXT", "utxt", "TUTX", "****"],
extensions: extensions,
iconFile: icon
};
}
export const config = {
version: getElectronVersion(),
productAppName: product.nameLong,
companyName: 'Microsoft Corporation',
copyright: 'Copyright (C) 2019 Microsoft. All rights reserved',
darwinIcon: 'resources/darwin/code.icns',
darwinBundleIdentifier: product.darwinBundleIdentifier,
darwinApplicationCategoryType: 'public.app-category.developer-tools',
darwinHelpBookFolder: 'VS Code HelpBook',
darwinHelpBookName: 'VS Code HelpBook',
darwinBundleDocumentTypes: [
darwinBundleDocumentType(["bat", "cmd"], 'resources/darwin/bat.icns'),
darwinBundleDocumentType(["bowerrc"], 'resources/darwin/bower.icns'),
darwinBundleDocumentType(["c", "h"], 'resources/darwin/c.icns'),
darwinBundleDocumentType(["config", "editorconfig", "gitattributes", "gitconfig", "gitignore", "ini"], 'resources/darwin/config.icns'),
darwinBundleDocumentType(["cc", "cpp", "cxx", "hh", "hpp", "hxx"], 'resources/darwin/cpp.icns'),
darwinBundleDocumentType(["cs", "csx"], 'resources/darwin/csharp.icns'),
darwinBundleDocumentType(["css"], 'resources/darwin/css.icns'),
darwinBundleDocumentType(["go"], 'resources/darwin/go.icns'),
darwinBundleDocumentType(["asp", "aspx", "cshtml", "htm", "html", "jshtm", "jsp", "phtml", "shtml"], 'resources/darwin/html.icns'),
darwinBundleDocumentType(["jade"], 'resources/darwin/jade.icns'),
darwinBundleDocumentType(["jav", "java"], 'resources/darwin/java.icns'),
darwinBundleDocumentType(["js", "jscsrc", "jshintrc", "mjs"], 'resources/darwin/javascript.icns'),
darwinBundleDocumentType(["json"], 'resources/darwin/json.icns'),
darwinBundleDocumentType(["less"], 'resources/darwin/less.icns'),
darwinBundleDocumentType(["markdown", "md", "mdoc", "mdown", "mdtext", "mdtxt", "mdwn", "mkd", "mkdn"], 'resources/darwin/markdown.icns'),
darwinBundleDocumentType(["php"], 'resources/darwin/php.icns'),
darwinBundleDocumentType(["ps1", "psd1", "psm1"], 'resources/darwin/powershell.icns'),
darwinBundleDocumentType(["py"], 'resources/darwin/python.icns'),
darwinBundleDocumentType(["gemspec", "rb"], 'resources/darwin/ruby.icns'),
darwinBundleDocumentType(["scss"], 'resources/darwin/sass.icns'),
darwinBundleDocumentType(["bash", "bash_login", "bash_logout", "bash_profile", "bashrc", "profile", "rhistory", "rprofile", "sh", "zlogin", "zlogout", "zprofile", "zsh", "zshenv", "zshrc"], 'resources/darwin/shell.icns'),
darwinBundleDocumentType(["sql"], 'resources/darwin/sql.icns'),
darwinBundleDocumentType(["ts"], 'resources/darwin/typescript.icns'),
darwinBundleDocumentType(["tsx", "jsx"], 'resources/darwin/react.icns'),
darwinBundleDocumentType(["vue"], 'resources/darwin/vue.icns'),
darwinBundleDocumentType(["ascx", "csproj", "dtd", "wxi", "wxl", "wxs", "xml", "xaml"], 'resources/darwin/xml.icns'),
darwinBundleDocumentType(["eyaml", "eyml", "yaml", "yml"], 'resources/darwin/yaml.icns'),
darwinBundleDocumentType(["clj", "cljs", "cljx", "clojure", "code-workspace", "coffee", "ctp", "dockerfile", "dot", "edn", "fs", "fsi", "fsscript", "fsx", "handlebars", "hbs", "lua", "m", "makefile", "ml", "mli", "pl", "pl6", "pm", "pm6", "pod", "pp", "properties", "psgi", "pug", "r", "rs", "rt", "svg", "svgz", "t", "txt", "vb", "xcodeproj", "xcworkspace"], 'resources/darwin/default.icns')
],
darwinBundleURLTypes: [{
role: 'Viewer',
name: product.nameLong,
urlSchemes: [product.urlProtocol]
}],
darwinForceDarkModeSupport: true,
darwinCredits: darwinCreditsTemplate ? Buffer.from(darwinCreditsTemplate({ commit: commit, date: new Date().toISOString() })) : undefined,
linuxExecutableName: product.applicationName,
winIcon: 'resources/win32/code.ico',
token: process.env['VSCODE_MIXIN_PASSWORD'] || process.env['GITHUB_TOKEN'] || undefined,
repo: product.electronRepository || undefined
};
function getElectron(arch: string): () => NodeJS.ReadWriteStream {
return () => {
const electronOpts = _.extend({}, config, {
platform: process.platform,
arch,
ffmpegChromium: true,
keepDefaultApp: true
});
return vfs.src('package.json')
.pipe(json({ name: product.nameShort }))
.pipe(electron(electronOpts))
.pipe(filter(['**', '!**/app/package.json']))
.pipe(vfs.dest('.build/electron'));
};
}
async function main(arch = process.arch): Promise {
const version = getElectronVersion();
const electronPath = path.join(root, '.build', 'electron');
const versionFile = path.join(electronPath, 'version');
const isUpToDate = fs.existsSync(versionFile) && fs.readFileSync(versionFile, 'utf8') === `${version}`;
if (!isUpToDate) {
await util.rimraf(electronPath)();
await util.streamToPromise(getElectron(arch)());
}
}
if (require.main === module) {
main(process.argv[2]).catch(err => {
console.error(err);
process.exit(1);
});
}
================================================
FILE: build/lib/extensions.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const es = require("event-stream");
const fs = require("fs");
const glob = require("glob");
const gulp = require("gulp");
const path = require("path");
const File = require("vinyl");
const vsce = require("vsce");
const stats_1 = require("./stats");
const util2 = require("./util");
const remote = require("gulp-remote-retry-src");
const vzip = require('gulp-vinyl-zip');
const filter = require("gulp-filter");
const rename = require("gulp-rename");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const buffer = require('gulp-buffer');
const json = require("gulp-json-editor");
const webpack = require('webpack');
const webpackGulp = require('webpack-stream');
const util = require('./util');
const root = path.dirname(path.dirname(__dirname));
const commit = util.getVersion(root);
const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
function fromLocal(extensionPath) {
const webpackFilename = path.join(extensionPath, 'extension.webpack.config.js');
const input = fs.existsSync(webpackFilename)
? fromLocalWebpack(extensionPath)
: fromLocalNormal(extensionPath);
const tmLanguageJsonFilter = filter('**/*.tmLanguage.json', { restore: true });
return input
.pipe(tmLanguageJsonFilter)
.pipe(buffer())
.pipe(es.mapSync((f) => {
f.contents = Buffer.from(JSON.stringify(JSON.parse(f.contents.toString('utf8'))));
return f;
}))
.pipe(tmLanguageJsonFilter.restore);
}
function fromLocalWebpack(extensionPath) {
const result = es.through();
const packagedDependencies = [];
const packageJsonConfig = require(path.join(extensionPath, 'package.json'));
if (packageJsonConfig.dependencies) {
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
}
}
}
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn, packagedDependencies }).then(fileNames => {
const files = fileNames
.map(fileName => path.join(extensionPath, fileName))
.map(filePath => new File({
path: filePath,
stat: fs.statSync(filePath),
base: extensionPath,
contents: fs.createReadStream(filePath)
}));
const filesStream = es.readArray(files);
// check for a webpack configuration files, then invoke webpack
// and merge its output with the files stream. also rewrite the package.json
// file to a new entry point
const webpackConfigLocations = glob.sync(path.join(extensionPath, '/**/extension.webpack.config.js'), { ignore: ['**/node_modules'] });
const packageJsonFilter = filter(f => {
if (path.basename(f.path) === 'package.json') {
// only modify package.json's next to the webpack file.
// to be safe, use existsSync instead of path comparison.
return fs.existsSync(path.join(path.dirname(f.path), 'extension.webpack.config.js'));
}
return false;
}, { restore: true });
const patchFilesStream = filesStream
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json((data) => {
if (data.main) {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
}
return data;
}))
.pipe(packageJsonFilter.restore);
const webpackStreams = webpackConfigLocations.map(webpackConfigPath => {
const webpackDone = (err, stats) => {
fancyLog(`Bundled extension: ${ansiColors.yellow(path.join(path.basename(extensionPath), path.relative(extensionPath, webpackConfigPath)))}...`);
if (err) {
result.emit('error', err);
}
const { compilation } = stats;
if (compilation.errors.length > 0) {
result.emit('error', compilation.errors.join('\n'));
}
if (compilation.warnings.length > 0) {
result.emit('error', compilation.warnings.join('\n'));
}
};
const webpackConfig = Object.assign(Object.assign({}, require(webpackConfigPath)), { mode: 'production' });
const relativeOutputPath = path.relative(extensionPath, webpackConfig.output.path);
return webpackGulp(webpackConfig, webpack, webpackDone)
.pipe(es.through(function (data) {
data.stat = data.stat || {};
data.base = extensionPath;
this.emit('data', data);
}))
.pipe(es.through(function (data) {
// source map handling:
// * rewrite sourceMappingURL
// * save to disk so that upload-task picks this up
const contents = data.contents.toString('utf8');
data.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, function (_m, g1) {
return `\n//# sourceMappingURL=${sourceMappingURLBase}/extensions/${path.basename(extensionPath)}/${relativeOutputPath}/${g1}`;
}), 'utf8');
this.emit('data', data);
}));
});
es.merge(...webpackStreams, patchFilesStream)
// .pipe(es.through(function (data) {
// // debug
// console.log('out', data.path, data.contents.length);
// this.emit('data', data);
// }))
.pipe(result);
}).catch(err => {
console.error(extensionPath);
console.error(packagedDependencies);
result.emit('error', err);
});
return result.pipe(stats_1.createStatsStream(path.basename(extensionPath)));
}
function fromLocalNormal(extensionPath) {
const result = es.through();
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn })
.then(fileNames => {
const files = fileNames
.map(fileName => path.join(extensionPath, fileName))
.map(filePath => new File({
path: filePath,
stat: fs.statSync(filePath),
base: extensionPath,
contents: fs.createReadStream(filePath)
}));
es.readArray(files).pipe(result);
})
.catch(err => result.emit('error', err));
return result.pipe(stats_1.createStatsStream(path.basename(extensionPath)));
}
const baseHeaders = {
'X-Market-Client-Id': 'VSCode Build',
'User-Agent': 'VSCode Build',
'X-Market-User-Id': '291C1CD0-051A-4123-9B4B-30D60EF52EE2',
};
function fromMarketplace(extensionName, version, metadata) {
const [publisher, name] = extensionName.split('.');
const url = `https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${publisher}/vsextensions/${name}/${version}/vspackage`;
fancyLog('Downloading extension:', ansiColors.yellow(`${extensionName}@${version}`), '...');
const options = {
base: url,
requestOptions: {
gzip: true,
headers: baseHeaders
}
};
const packageJsonFilter = filter('package.json', { restore: true });
return remote('', options)
.pipe(vzip.src())
.pipe(filter('extension/**'))
.pipe(rename(p => p.dirname = p.dirname.replace(/^extension\/?/, '')))
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json({ __metadata: metadata }))
.pipe(packageJsonFilter.restore);
}
exports.fromMarketplace = fromMarketplace;
const excludedExtensions = [
'vscode-api-tests',
'vscode-colorize-tests',
'vscode-test-resolver',
'ms-vscode.node-debug',
'ms-vscode.node-debug2',
];
const builtInExtensions = require('../builtInExtensions.json');
function packageLocalExtensionsStream() {
const localExtensionDescriptions = glob.sync('extensions/*/package.json')
.map(manifestPath => {
const extensionPath = path.dirname(path.join(root, manifestPath));
const extensionName = path.basename(extensionPath);
return { name: extensionName, path: extensionPath };
})
.filter(({ name }) => excludedExtensions.indexOf(name) === -1)
.filter(({ name }) => builtInExtensions.every(b => b.name !== name));
const nodeModules = gulp.src('extensions/node_modules/**', { base: '.' });
const localExtensions = localExtensionDescriptions.map(extension => {
return fromLocal(extension.path)
.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
});
return es.merge(nodeModules, ...localExtensions)
.pipe(util2.setExecutableBit(['**/*.sh']));
}
exports.packageLocalExtensionsStream = packageLocalExtensionsStream;
function packageMarketplaceExtensionsStream() {
const extensions = builtInExtensions.map(extension => {
return fromMarketplace(extension.name, extension.version, extension.metadata)
.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
});
return es.merge(extensions)
.pipe(util2.setExecutableBit(['**/*.sh']));
}
exports.packageMarketplaceExtensionsStream = packageMarketplaceExtensionsStream;
================================================
FILE: build/lib/extensions.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as es from 'event-stream';
import * as fs from 'fs';
import * as glob from 'glob';
import * as gulp from 'gulp';
import * as path from 'path';
import { Stream } from 'stream';
import * as File from 'vinyl';
import * as vsce from 'vsce';
import { createStatsStream } from './stats';
import * as util2 from './util';
import remote = require('gulp-remote-retry-src');
const vzip = require('gulp-vinyl-zip');
import filter = require('gulp-filter');
import rename = require('gulp-rename');
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
const buffer = require('gulp-buffer');
import json = require('gulp-json-editor');
const webpack = require('webpack');
const webpackGulp = require('webpack-stream');
const util = require('./util');
const root = path.dirname(path.dirname(__dirname));
const commit = util.getVersion(root);
const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
function fromLocal(extensionPath: string): Stream {
const webpackFilename = path.join(extensionPath, 'extension.webpack.config.js');
const input = fs.existsSync(webpackFilename)
? fromLocalWebpack(extensionPath)
: fromLocalNormal(extensionPath);
const tmLanguageJsonFilter = filter('**/*.tmLanguage.json', { restore: true });
return input
.pipe(tmLanguageJsonFilter)
.pipe(buffer())
.pipe(es.mapSync((f: File) => {
f.contents = Buffer.from(JSON.stringify(JSON.parse(f.contents.toString('utf8'))));
return f;
}))
.pipe(tmLanguageJsonFilter.restore);
}
function fromLocalWebpack(extensionPath: string): Stream {
const result = es.through();
const packagedDependencies: string[] = [];
const packageJsonConfig = require(path.join(extensionPath, 'package.json'));
if (packageJsonConfig.dependencies) {
const webpackRootConfig = require(path.join(extensionPath, 'extension.webpack.config.js'));
for (const key in webpackRootConfig.externals) {
if (key in packageJsonConfig.dependencies) {
packagedDependencies.push(key);
}
}
}
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn, packagedDependencies }).then(fileNames => {
const files = fileNames
.map(fileName => path.join(extensionPath, fileName))
.map(filePath => new File({
path: filePath,
stat: fs.statSync(filePath),
base: extensionPath,
contents: fs.createReadStream(filePath) as any
}));
const filesStream = es.readArray(files);
// check for a webpack configuration files, then invoke webpack
// and merge its output with the files stream. also rewrite the package.json
// file to a new entry point
const webpackConfigLocations = (glob.sync(
path.join(extensionPath, '/**/extension.webpack.config.js'),
{ ignore: ['**/node_modules'] }
));
const packageJsonFilter = filter(f => {
if (path.basename(f.path) === 'package.json') {
// only modify package.json's next to the webpack file.
// to be safe, use existsSync instead of path comparison.
return fs.existsSync(path.join(path.dirname(f.path), 'extension.webpack.config.js'));
}
return false;
}, { restore: true });
const patchFilesStream = filesStream
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json((data: any) => {
if (data.main) {
// hardcoded entry point directory!
data.main = data.main.replace('/out/', /dist/);
}
return data;
}))
.pipe(packageJsonFilter.restore);
const webpackStreams = webpackConfigLocations.map(webpackConfigPath => {
const webpackDone = (err: any, stats: any) => {
fancyLog(`Bundled extension: ${ansiColors.yellow(path.join(path.basename(extensionPath), path.relative(extensionPath, webpackConfigPath)))}...`);
if (err) {
result.emit('error', err);
}
const { compilation } = stats;
if (compilation.errors.length > 0) {
result.emit('error', compilation.errors.join('\n'));
}
if (compilation.warnings.length > 0) {
result.emit('error', compilation.warnings.join('\n'));
}
};
const webpackConfig = {
...require(webpackConfigPath),
...{ mode: 'production' }
};
const relativeOutputPath = path.relative(extensionPath, webpackConfig.output.path);
return webpackGulp(webpackConfig, webpack, webpackDone)
.pipe(es.through(function (data) {
data.stat = data.stat || {};
data.base = extensionPath;
this.emit('data', data);
}))
.pipe(es.through(function (data: File) {
// source map handling:
// * rewrite sourceMappingURL
// * save to disk so that upload-task picks this up
const contents = (data.contents).toString('utf8');
data.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, function (_m, g1) {
return `\n//# sourceMappingURL=${sourceMappingURLBase}/extensions/${path.basename(extensionPath)}/${relativeOutputPath}/${g1}`;
}), 'utf8');
this.emit('data', data);
}));
});
es.merge(...webpackStreams, patchFilesStream)
// .pipe(es.through(function (data) {
// // debug
// console.log('out', data.path, data.contents.length);
// this.emit('data', data);
// }))
.pipe(result);
}).catch(err => {
console.error(extensionPath);
console.error(packagedDependencies);
result.emit('error', err);
});
return result.pipe(createStatsStream(path.basename(extensionPath)));
}
function fromLocalNormal(extensionPath: string): Stream {
const result = es.through();
vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn })
.then(fileNames => {
const files = fileNames
.map(fileName => path.join(extensionPath, fileName))
.map(filePath => new File({
path: filePath,
stat: fs.statSync(filePath),
base: extensionPath,
contents: fs.createReadStream(filePath) as any
}));
es.readArray(files).pipe(result);
})
.catch(err => result.emit('error', err));
return result.pipe(createStatsStream(path.basename(extensionPath)));
}
const baseHeaders = {
'X-Market-Client-Id': 'VSCode Build',
'User-Agent': 'VSCode Build',
'X-Market-User-Id': '291C1CD0-051A-4123-9B4B-30D60EF52EE2',
};
export function fromMarketplace(extensionName: string, version: string, metadata: any): Stream {
const [publisher, name] = extensionName.split('.');
const url = `https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${publisher}/vsextensions/${name}/${version}/vspackage`;
fancyLog('Downloading extension:', ansiColors.yellow(`${extensionName}@${version}`), '...');
const options = {
base: url,
requestOptions: {
gzip: true,
headers: baseHeaders
}
};
const packageJsonFilter = filter('package.json', { restore: true });
return remote('', options)
.pipe(vzip.src())
.pipe(filter('extension/**'))
.pipe(rename(p => p.dirname = p.dirname!.replace(/^extension\/?/, '')))
.pipe(packageJsonFilter)
.pipe(buffer())
.pipe(json({ __metadata: metadata }))
.pipe(packageJsonFilter.restore);
}
const excludedExtensions = [
'vscode-api-tests',
'vscode-colorize-tests',
'vscode-test-resolver',
'ms-vscode.node-debug',
'ms-vscode.node-debug2',
];
interface IBuiltInExtension {
name: string;
version: string;
repo: string;
metadata: any;
}
const builtInExtensions: IBuiltInExtension[] = require('../builtInExtensions.json');
export function packageLocalExtensionsStream(): NodeJS.ReadWriteStream {
const localExtensionDescriptions = (glob.sync('extensions/*/package.json'))
.map(manifestPath => {
const extensionPath = path.dirname(path.join(root, manifestPath));
const extensionName = path.basename(extensionPath);
return { name: extensionName, path: extensionPath };
})
.filter(({ name }) => excludedExtensions.indexOf(name) === -1)
.filter(({ name }) => builtInExtensions.every(b => b.name !== name));
const nodeModules = gulp.src('extensions/node_modules/**', { base: '.' });
const localExtensions = localExtensionDescriptions.map(extension => {
return fromLocal(extension.path)
.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
});
return es.merge(nodeModules, ...localExtensions)
.pipe(util2.setExecutableBit(['**/*.sh']));
}
export function packageMarketplaceExtensionsStream(): NodeJS.ReadWriteStream {
const extensions = builtInExtensions.map(extension => {
return fromMarketplace(extension.name, extension.version, extension.metadata)
.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
});
return es.merge(extensions)
.pipe(util2.setExecutableBit(['**/*.sh']));
}
================================================
FILE: build/lib/git.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const path = require("path");
const fs = require("fs");
/**
* Returns the sha1 commit version of a repository or undefined in case of failure.
*/
function getVersion(repo) {
const git = path.join(repo, '.git');
const headPath = path.join(git, 'HEAD');
let head;
try {
head = fs.readFileSync(headPath, 'utf8').trim();
}
catch (e) {
return undefined;
}
if (/^[0-9a-f]{40}$/i.test(head)) {
return head;
}
const refMatch = /^ref: (.*)$/.exec(head);
if (!refMatch) {
return undefined;
}
const ref = refMatch[1];
const refPath = path.join(git, ref);
try {
return fs.readFileSync(refPath, 'utf8').trim();
}
catch (e) {
// noop
}
const packedRefsPath = path.join(git, 'packed-refs');
let refsRaw;
try {
refsRaw = fs.readFileSync(packedRefsPath, 'utf8').trim();
}
catch (e) {
return undefined;
}
const refsRegex = /^([0-9a-f]{40})\s+(.+)$/gm;
let refsMatch;
let refs = {};
while (refsMatch = refsRegex.exec(refsRaw)) {
refs[refsMatch[2]] = refsMatch[1];
}
return refs[ref];
}
exports.getVersion = getVersion;
================================================
FILE: build/lib/git.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as path from 'path';
import * as fs from 'fs';
/**
* Returns the sha1 commit version of a repository or undefined in case of failure.
*/
export function getVersion(repo: string): string | undefined {
const git = path.join(repo, '.git');
const headPath = path.join(git, 'HEAD');
let head: string;
try {
head = fs.readFileSync(headPath, 'utf8').trim();
} catch (e) {
return undefined;
}
if (/^[0-9a-f]{40}$/i.test(head)) {
return head;
}
const refMatch = /^ref: (.*)$/.exec(head);
if (!refMatch) {
return undefined;
}
const ref = refMatch[1];
const refPath = path.join(git, ref);
try {
return fs.readFileSync(refPath, 'utf8').trim();
} catch (e) {
// noop
}
const packedRefsPath = path.join(git, 'packed-refs');
let refsRaw: string;
try {
refsRaw = fs.readFileSync(packedRefsPath, 'utf8').trim();
} catch (e) {
return undefined;
}
const refsRegex = /^([0-9a-f]{40})\s+(.+)$/gm;
let refsMatch: RegExpExecArray | null;
let refs: { [ref: string]: string } = {};
while (refsMatch = refsRegex.exec(refsRaw)) {
refs[refsMatch[2]] = refsMatch[1];
}
return refs[ref];
}
================================================
FILE: build/lib/i18n.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fs = require("fs");
const event_stream_1 = require("event-stream");
const File = require("vinyl");
const Is = require("is");
const xml2js = require("xml2js");
const glob = require("glob");
const https = require("https");
const gulp = require("gulp");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const iconv = require("iconv-lite");
const NUMBER_OF_CONCURRENT_DOWNLOADS = 4;
function log(message, ...rest) {
fancyLog(ansiColors.green('[i18n]'), message, ...rest);
}
exports.defaultLanguages = [
{ id: 'zh-tw', folderName: 'cht', translationId: 'zh-hant' },
{ id: 'zh-cn', folderName: 'chs', translationId: 'zh-hans' },
{ id: 'ja', folderName: 'jpn' },
{ id: 'ko', folderName: 'kor' },
{ id: 'de', folderName: 'deu' },
{ id: 'fr', folderName: 'fra' },
{ id: 'es', folderName: 'esn' },
{ id: 'ru', folderName: 'rus' },
{ id: 'it', folderName: 'ita' }
];
// languages requested by the community to non-stable builds
exports.extraLanguages = [
{ id: 'pt-br', folderName: 'ptb' },
{ id: 'hu', folderName: 'hun' },
{ id: 'tr', folderName: 'trk' }
];
// non built-in extensions also that are transifex and need to be part of the language packs
exports.externalExtensionsWithTranslations = {
'vscode-chrome-debug': 'msjsdiag.debugger-for-chrome',
'vscode-node-debug': 'ms-vscode.node-debug',
'vscode-node-debug2': 'ms-vscode.node-debug2'
};
var LocalizeInfo;
(function (LocalizeInfo) {
function is(value) {
let candidate = value;
return Is.defined(candidate) && Is.string(candidate.key) && (Is.undef(candidate.comment) || (Is.array(candidate.comment) && candidate.comment.every(element => Is.string(element))));
}
LocalizeInfo.is = is;
})(LocalizeInfo || (LocalizeInfo = {}));
var BundledFormat;
(function (BundledFormat) {
function is(value) {
if (Is.undef(value)) {
return false;
}
let candidate = value;
let length = Object.keys(value).length;
return length === 3 && Is.defined(candidate.keys) && Is.defined(candidate.messages) && Is.defined(candidate.bundles);
}
BundledFormat.is = is;
})(BundledFormat || (BundledFormat = {}));
var PackageJsonFormat;
(function (PackageJsonFormat) {
function is(value) {
if (Is.undef(value) || !Is.object(value)) {
return false;
}
return Object.keys(value).every(key => {
let element = value[key];
return Is.string(element) || (Is.object(element) && Is.defined(element.message) && Is.defined(element.comment));
});
}
PackageJsonFormat.is = is;
})(PackageJsonFormat || (PackageJsonFormat = {}));
class Line {
constructor(indent = 0) {
this.buffer = [];
if (indent > 0) {
this.buffer.push(new Array(indent + 1).join(' '));
}
}
append(value) {
this.buffer.push(value);
return this;
}
toString() {
return this.buffer.join('');
}
}
exports.Line = Line;
class TextModel {
constructor(contents) {
this._lines = contents.split(/\r\n|\r|\n/);
}
get lines() {
return this._lines;
}
}
class XLF {
constructor(project) {
this.project = project;
this.buffer = [];
this.files = Object.create(null);
this.numberOfMessages = 0;
}
toString() {
this.appendHeader();
for (let file in this.files) {
this.appendNewLine(``, 2);
for (let item of this.files[file]) {
this.addStringItem(item);
}
this.appendNewLine('', 2);
}
this.appendFooter();
return this.buffer.join('\r\n');
}
addFile(original, keys, messages) {
if (keys.length === 0) {
console.log('No keys in ' + original);
return;
}
if (keys.length !== messages.length) {
throw new Error(`Unmatching keys(${keys.length}) and messages(${messages.length}).`);
}
this.numberOfMessages += keys.length;
this.files[original] = [];
let existingKeys = new Set();
for (let i = 0; i < keys.length; i++) {
let key = keys[i];
let realKey;
let comment;
if (Is.string(key)) {
realKey = key;
comment = undefined;
}
else if (LocalizeInfo.is(key)) {
realKey = key.key;
if (key.comment && key.comment.length > 0) {
comment = key.comment.map(comment => encodeEntities(comment)).join('\r\n');
}
}
if (!realKey || existingKeys.has(realKey)) {
continue;
}
existingKeys.add(realKey);
let message = encodeEntities(messages[i]);
this.files[original].push({ id: realKey, message: message, comment: comment });
}
}
addStringItem(item) {
if (!item.id || !item.message) {
throw new Error(`No item ID or value specified: ${JSON.stringify(item)}`);
}
this.appendNewLine(``, 4);
this.appendNewLine(`${item.message}`, 6);
if (item.comment) {
this.appendNewLine(`${item.comment}`, 6);
}
this.appendNewLine('', 4);
}
appendHeader() {
this.appendNewLine('', 0);
this.appendNewLine('', 0);
}
appendFooter() {
this.appendNewLine('', 0);
}
appendNewLine(content, indent) {
let line = new Line(indent);
line.append(content);
this.buffer.push(line.toString());
}
}
exports.XLF = XLF;
XLF.parsePseudo = function (xlfString) {
return new Promise((resolve) => {
let parser = new xml2js.Parser();
let files = [];
parser.parseString(xlfString, function (_err, result) {
const fileNodes = result['xliff']['file'];
fileNodes.forEach(file => {
const originalFilePath = file.$.original;
const messages = {};
const transUnits = file.body[0]['trans-unit'];
if (transUnits) {
transUnits.forEach((unit) => {
const key = unit.$.id;
const val = pseudify(unit.source[0]['_'].toString());
if (key && val) {
messages[key] = decodeEntities(val);
}
});
files.push({ messages: messages, originalFilePath: originalFilePath, language: 'ps' });
}
});
resolve(files);
});
});
};
XLF.parse = function (xlfString) {
return new Promise((resolve, reject) => {
let parser = new xml2js.Parser();
let files = [];
parser.parseString(xlfString, function (err, result) {
if (err) {
reject(new Error(`XLF parsing error: Failed to parse XLIFF string. ${err}`));
}
const fileNodes = result['xliff']['file'];
if (!fileNodes) {
reject(new Error(`XLF parsing error: XLIFF file does not contain "xliff" or "file" node(s) required for parsing.`));
}
fileNodes.forEach((file) => {
const originalFilePath = file.$.original;
if (!originalFilePath) {
reject(new Error(`XLF parsing error: XLIFF file node does not contain original attribute to determine the original location of the resource file.`));
}
let language = file.$['target-language'];
if (!language) {
reject(new Error(`XLF parsing error: XLIFF file node does not contain target-language attribute to determine translated language.`));
}
const messages = {};
const transUnits = file.body[0]['trans-unit'];
if (transUnits) {
transUnits.forEach((unit) => {
const key = unit.$.id;
if (!unit.target) {
return; // No translation available
}
let val = unit.target[0];
if (typeof val !== 'string') {
val = val._;
}
if (key && val) {
messages[key] = decodeEntities(val);
}
else {
reject(new Error(`XLF parsing error: XLIFF file ${originalFilePath} does not contain full localization data. ID or target translation for one of the trans-unit nodes is not present.`));
}
});
files.push({ messages: messages, originalFilePath: originalFilePath, language: language.toLowerCase() });
}
});
resolve(files);
});
});
};
class Limiter {
constructor(maxDegreeOfParalellism) {
this.maxDegreeOfParalellism = maxDegreeOfParalellism;
this.outstandingPromises = [];
this.runningPromises = 0;
}
queue(factory) {
return new Promise((c, e) => {
this.outstandingPromises.push({ factory, c, e });
this.consume();
});
}
consume() {
while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
const iLimitedTask = this.outstandingPromises.shift();
this.runningPromises++;
const promise = iLimitedTask.factory();
promise.then(iLimitedTask.c).catch(iLimitedTask.e);
promise.then(() => this.consumed()).catch(() => this.consumed());
}
}
consumed() {
this.runningPromises--;
this.consume();
}
}
exports.Limiter = Limiter;
function sortLanguages(languages) {
return languages.sort((a, b) => {
return a.id < b.id ? -1 : (a.id > b.id ? 1 : 0);
});
}
function stripComments(content) {
/**
* First capturing group matches double quoted string
* Second matches single quotes string
* Third matches block comments
* Fourth matches line comments
*/
const regexp = /("(?:[^\\\"]*(?:\\.)?)*")|('(?:[^\\\']*(?:\\.)?)*')|(\/\*(?:\r?\n|.)*?\*\/)|(\/{2,}.*?(?:(?:\r?\n)|$))/g;
let result = content.replace(regexp, (match, _m1, _m2, m3, m4) => {
// Only one of m1, m2, m3, m4 matches
if (m3) {
// A block comment. Replace with nothing
return '';
}
else if (m4) {
// A line comment. If it ends in \r?\n then keep it.
let length = m4.length;
if (length > 2 && m4[length - 1] === '\n') {
return m4[length - 2] === '\r' ? '\r\n' : '\n';
}
else {
return '';
}
}
else {
// We match a string
return match;
}
});
return result;
}
function escapeCharacters(value) {
const result = [];
for (let i = 0; i < value.length; i++) {
const ch = value.charAt(i);
switch (ch) {
case '\'':
result.push('\\\'');
break;
case '"':
result.push('\\"');
break;
case '\\':
result.push('\\\\');
break;
case '\n':
result.push('\\n');
break;
case '\r':
result.push('\\r');
break;
case '\t':
result.push('\\t');
break;
case '\b':
result.push('\\b');
break;
case '\f':
result.push('\\f');
break;
default:
result.push(ch);
}
}
return result.join('');
}
function processCoreBundleFormat(fileHeader, languages, json, emitter) {
let keysSection = json.keys;
let messageSection = json.messages;
let bundleSection = json.bundles;
let statistics = Object.create(null);
let defaultMessages = Object.create(null);
let modules = Object.keys(keysSection);
modules.forEach((module) => {
let keys = keysSection[module];
let messages = messageSection[module];
if (!messages || keys.length !== messages.length) {
emitter.emit('error', `Message for module ${module} corrupted. Mismatch in number of keys and messages.`);
return;
}
let messageMap = Object.create(null);
defaultMessages[module] = messageMap;
keys.map((key, i) => {
if (typeof key === 'string') {
messageMap[key] = messages[i];
}
else {
messageMap[key.key] = messages[i];
}
});
});
let languageDirectory = path.join(__dirname, '..', '..', '..', 'vscode-loc', 'i18n');
if (!fs.existsSync(languageDirectory)) {
log(`No VS Code localization repository found. Looking at ${languageDirectory}`);
log(`To bundle translations please check out the vscode-loc repository as a sibling of the vscode repository.`);
}
let sortedLanguages = sortLanguages(languages);
sortedLanguages.forEach((language) => {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`Generating nls bundles for: ${language.id}`);
}
statistics[language.id] = 0;
let localizedModules = Object.create(null);
let languageFolderName = language.translationId || language.id;
let i18nFile = path.join(languageDirectory, `vscode-language-pack-${languageFolderName}`, 'translations', 'main.i18n.json');
let allMessages;
if (fs.existsSync(i18nFile)) {
let content = stripComments(fs.readFileSync(i18nFile, 'utf8'));
allMessages = JSON.parse(content);
}
modules.forEach((module) => {
let order = keysSection[module];
let moduleMessage;
if (allMessages) {
moduleMessage = allMessages.contents[module];
}
if (!moduleMessage) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`No localized messages found for module ${module}. Using default messages.`);
}
moduleMessage = defaultMessages[module];
statistics[language.id] = statistics[language.id] + Object.keys(moduleMessage).length;
}
let localizedMessages = [];
order.forEach((keyInfo) => {
let key = null;
if (typeof keyInfo === 'string') {
key = keyInfo;
}
else {
key = keyInfo.key;
}
let message = moduleMessage[key];
if (!message) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`No localized message found for key ${key} in module ${module}. Using default message.`);
}
message = defaultMessages[module][key];
statistics[language.id] = statistics[language.id] + 1;
}
localizedMessages.push(message);
});
localizedModules[module] = localizedMessages;
});
Object.keys(bundleSection).forEach((bundle) => {
let modules = bundleSection[bundle];
let contents = [
fileHeader,
`define("${bundle}.nls.${language.id}", {`
];
modules.forEach((module, index) => {
contents.push(`\t"${module}": [`);
let messages = localizedModules[module];
if (!messages) {
emitter.emit('error', `Didn't find messages for module ${module}.`);
return;
}
messages.forEach((message, index) => {
contents.push(`\t\t"${escapeCharacters(message)}${index < messages.length ? '",' : '"'}`);
});
contents.push(index < modules.length - 1 ? '\t],' : '\t]');
});
contents.push('});');
emitter.queue(new File({ path: bundle + '.nls.' + language.id + '.js', contents: Buffer.from(contents.join('\n'), 'utf-8') }));
});
});
Object.keys(statistics).forEach(key => {
let value = statistics[key];
log(`${key} has ${value} untranslated strings.`);
});
sortedLanguages.forEach(language => {
let stats = statistics[language.id];
if (Is.undef(stats)) {
log(`\tNo translations found for language ${language.id}. Using default language instead.`);
}
});
}
function processNlsFiles(opts) {
return event_stream_1.through(function (file) {
let fileName = path.basename(file.path);
if (fileName === 'nls.metadata.json') {
let json = null;
if (file.isBuffer()) {
json = JSON.parse(file.contents.toString('utf8'));
}
else {
this.emit('error', `Failed to read component file: ${file.relative}`);
return;
}
if (BundledFormat.is(json)) {
processCoreBundleFormat(opts.fileHeader, opts.languages, json, this);
}
}
this.queue(file);
});
}
exports.processNlsFiles = processNlsFiles;
const editorProject = 'vscode-editor', workbenchProject = 'vscode-workbench', extensionsProject = 'vscode-extensions', setupProject = 'vscode-setup';
function getResource(sourceFile) {
let resource;
if (/^vs\/platform/.test(sourceFile)) {
return { name: 'vs/platform', project: editorProject };
}
else if (/^vs\/editor\/contrib/.test(sourceFile)) {
return { name: 'vs/editor/contrib', project: editorProject };
}
else if (/^vs\/editor/.test(sourceFile)) {
return { name: 'vs/editor', project: editorProject };
}
else if (/^vs\/base/.test(sourceFile)) {
return { name: 'vs/base', project: editorProject };
}
else if (/^vs\/code/.test(sourceFile)) {
return { name: 'vs/code', project: workbenchProject };
}
else if (/^vs\/workbench\/contrib/.test(sourceFile)) {
resource = sourceFile.split('/', 4).join('/');
return { name: resource, project: workbenchProject };
}
else if (/^vs\/workbench\/services/.test(sourceFile)) {
resource = sourceFile.split('/', 4).join('/');
return { name: resource, project: workbenchProject };
}
else if (/^vs\/workbench/.test(sourceFile)) {
return { name: 'vs/workbench', project: workbenchProject };
}
throw new Error(`Could not identify the XLF bundle for ${sourceFile}`);
}
exports.getResource = getResource;
function createXlfFilesForCoreBundle() {
return event_stream_1.through(function (file) {
const basename = path.basename(file.path);
if (basename === 'nls.metadata.json') {
if (file.isBuffer()) {
const xlfs = Object.create(null);
const json = JSON.parse(file.contents.toString('utf8'));
for (let coreModule in json.keys) {
const projectResource = getResource(coreModule);
const resource = projectResource.name;
const project = projectResource.project;
const keys = json.keys[coreModule];
const messages = json.messages[coreModule];
if (keys.length !== messages.length) {
this.emit('error', `There is a mismatch between keys and messages in ${file.relative} for module ${coreModule}`);
return;
}
else {
let xlf = xlfs[resource];
if (!xlf) {
xlf = new XLF(project);
xlfs[resource] = xlf;
}
xlf.addFile(`src/${coreModule}`, keys, messages);
}
}
for (let resource in xlfs) {
const xlf = xlfs[resource];
const filePath = `${xlf.project}/${resource.replace(/\//g, '_')}.xlf`;
const xlfFile = new File({
path: filePath,
contents: Buffer.from(xlf.toString(), 'utf8')
});
this.queue(xlfFile);
}
}
else {
this.emit('error', new Error(`File ${file.relative} is not using a buffer content`));
return;
}
}
else {
this.emit('error', new Error(`File ${file.relative} is not a core meta data file.`));
return;
}
});
}
exports.createXlfFilesForCoreBundle = createXlfFilesForCoreBundle;
function createXlfFilesForExtensions() {
let counter = 0;
let folderStreamEnded = false;
let folderStreamEndEmitted = false;
return event_stream_1.through(function (extensionFolder) {
const folderStream = this;
const stat = fs.statSync(extensionFolder.path);
if (!stat.isDirectory()) {
return;
}
let extensionName = path.basename(extensionFolder.path);
if (extensionName === 'node_modules') {
return;
}
counter++;
let _xlf;
function getXlf() {
if (!_xlf) {
_xlf = new XLF(extensionsProject);
}
return _xlf;
}
gulp.src([`.build/extensions/${extensionName}/package.nls.json`, `.build/extensions/${extensionName}/**/nls.metadata.json`], { allowEmpty: true }).pipe(event_stream_1.through(function (file) {
if (file.isBuffer()) {
const buffer = file.contents;
const basename = path.basename(file.path);
if (basename === 'package.nls.json') {
const json = JSON.parse(buffer.toString('utf8'));
const keys = Object.keys(json);
const messages = keys.map((key) => {
const value = json[key];
if (Is.string(value)) {
return value;
}
else if (value) {
return value.message;
}
else {
return `Unknown message for key: ${key}`;
}
});
getXlf().addFile(`extensions/${extensionName}/package`, keys, messages);
}
else if (basename === 'nls.metadata.json') {
const json = JSON.parse(buffer.toString('utf8'));
const relPath = path.relative(`.build/extensions/${extensionName}`, path.dirname(file.path));
for (let file in json) {
const fileContent = json[file];
getXlf().addFile(`extensions/${extensionName}/${relPath}/${file}`, fileContent.keys, fileContent.messages);
}
}
else {
this.emit('error', new Error(`${file.path} is not a valid extension nls file`));
return;
}
}
}, function () {
if (_xlf) {
let xlfFile = new File({
path: path.join(extensionsProject, extensionName + '.xlf'),
contents: Buffer.from(_xlf.toString(), 'utf8')
});
folderStream.queue(xlfFile);
}
this.queue(null);
counter--;
if (counter === 0 && folderStreamEnded && !folderStreamEndEmitted) {
folderStreamEndEmitted = true;
folderStream.queue(null);
}
}));
}, function () {
folderStreamEnded = true;
if (counter === 0) {
folderStreamEndEmitted = true;
this.queue(null);
}
});
}
exports.createXlfFilesForExtensions = createXlfFilesForExtensions;
function createXlfFilesForIsl() {
return event_stream_1.through(function (file) {
let projectName, resourceFile;
if (path.basename(file.path) === 'Default.isl') {
projectName = setupProject;
resourceFile = 'setup_default.xlf';
}
else {
projectName = workbenchProject;
resourceFile = 'setup_messages.xlf';
}
let xlf = new XLF(projectName), keys = [], messages = [];
let model = new TextModel(file.contents.toString());
let inMessageSection = false;
model.lines.forEach(line => {
if (line.length === 0) {
return;
}
let firstChar = line.charAt(0);
switch (firstChar) {
case ';':
// Comment line;
return;
case '[':
inMessageSection = '[Messages]' === line || '[CustomMessages]' === line;
return;
}
if (!inMessageSection) {
return;
}
let sections = line.split('=');
if (sections.length !== 2) {
throw new Error(`Badly formatted message found: ${line}`);
}
else {
let key = sections[0];
let value = sections[1];
if (key.length > 0 && value.length > 0) {
keys.push(key);
messages.push(value);
}
}
});
const originalPath = file.path.substring(file.cwd.length + 1, file.path.split('.')[0].length).replace(/\\/g, '/');
xlf.addFile(originalPath, keys, messages);
// Emit only upon all ISL files combined into single XLF instance
const newFilePath = path.join(projectName, resourceFile);
const xlfFile = new File({ path: newFilePath, contents: Buffer.from(xlf.toString(), 'utf-8') });
this.queue(xlfFile);
});
}
exports.createXlfFilesForIsl = createXlfFilesForIsl;
function pushXlfFiles(apiHostname, username, password) {
let tryGetPromises = [];
let updateCreatePromises = [];
return event_stream_1.through(function (file) {
const project = path.dirname(file.relative);
const fileName = path.basename(file.path);
const slug = fileName.substr(0, fileName.length - '.xlf'.length);
const credentials = `${username}:${password}`;
// Check if resource already exists, if not, then create it.
let promise = tryGetResource(project, slug, apiHostname, credentials);
tryGetPromises.push(promise);
promise.then(exists => {
if (exists) {
promise = updateResource(project, slug, file, apiHostname, credentials);
}
else {
promise = createResource(project, slug, file, apiHostname, credentials);
}
updateCreatePromises.push(promise);
});
}, function () {
// End the pipe only after all the communication with Transifex API happened
Promise.all(tryGetPromises).then(() => {
Promise.all(updateCreatePromises).then(() => {
this.queue(null);
}).catch((reason) => { throw new Error(reason); });
}).catch((reason) => { throw new Error(reason); });
});
}
exports.pushXlfFiles = pushXlfFiles;
function getAllResources(project, apiHostname, username, password) {
return new Promise((resolve, reject) => {
const credentials = `${username}:${password}`;
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resources`,
auth: credentials,
method: 'GET'
};
const request = https.request(options, (res) => {
let buffer = [];
res.on('data', (chunk) => buffer.push(chunk));
res.on('end', () => {
if (res.statusCode === 200) {
let json = JSON.parse(Buffer.concat(buffer).toString());
if (Array.isArray(json)) {
resolve(json.map(o => o.slug));
return;
}
reject(`Unexpected data format. Response code: ${res.statusCode}.`);
}
else {
reject(`No resources in ${project} returned no data. Response code: ${res.statusCode}.`);
}
});
});
request.on('error', (err) => {
reject(`Failed to query resources in ${project} with the following error: ${err}. ${options.path}`);
});
request.end();
});
}
function findObsoleteResources(apiHostname, username, password) {
let resourcesByProject = Object.create(null);
resourcesByProject[extensionsProject] = [].concat(exports.externalExtensionsWithTranslations); // clone
return event_stream_1.through(function (file) {
const project = path.dirname(file.relative);
const fileName = path.basename(file.path);
const slug = fileName.substr(0, fileName.length - '.xlf'.length);
let slugs = resourcesByProject[project];
if (!slugs) {
resourcesByProject[project] = slugs = [];
}
slugs.push(slug);
this.push(file);
}, function () {
const json = JSON.parse(fs.readFileSync('./build/lib/i18n.resources.json', 'utf8'));
let i18Resources = [...json.editor, ...json.workbench].map((r) => r.project + '/' + r.name.replace(/\//g, '_'));
let extractedResources = [];
for (let project of [workbenchProject, editorProject]) {
for (let resource of resourcesByProject[project]) {
if (resource !== 'setup_messages') {
extractedResources.push(project + '/' + resource);
}
}
}
if (i18Resources.length !== extractedResources.length) {
console.log(`[i18n] Obsolete resources in file 'build/lib/i18n.resources.json': JSON.stringify(${i18Resources.filter(p => extractedResources.indexOf(p) === -1)})`);
console.log(`[i18n] Missing resources in file 'build/lib/i18n.resources.json': JSON.stringify(${extractedResources.filter(p => i18Resources.indexOf(p) === -1)})`);
}
let promises = [];
for (let project in resourcesByProject) {
promises.push(getAllResources(project, apiHostname, username, password).then(resources => {
let expectedResources = resourcesByProject[project];
let unusedResources = resources.filter(resource => resource && expectedResources.indexOf(resource) === -1);
if (unusedResources.length) {
console.log(`[transifex] Obsolete resources in project '${project}': ${unusedResources.join(', ')}`);
}
}));
}
return Promise.all(promises).then(_ => {
this.push(null);
}).catch((reason) => { throw new Error(reason); });
});
}
exports.findObsoleteResources = findObsoleteResources;
function tryGetResource(project, slug, apiHostname, credentials) {
return new Promise((resolve, reject) => {
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/?details`,
auth: credentials,
method: 'GET'
};
const request = https.request(options, (response) => {
if (response.statusCode === 404) {
resolve(false);
}
else if (response.statusCode === 200) {
resolve(true);
}
else {
reject(`Failed to query resource ${project}/${slug}. Response: ${response.statusCode} ${response.statusMessage}`);
}
});
request.on('error', (err) => {
reject(`Failed to get ${project}/${slug} on Transifex: ${err}`);
});
request.end();
});
}
function createResource(project, slug, xlfFile, apiHostname, credentials) {
return new Promise((_resolve, reject) => {
const data = JSON.stringify({
'content': xlfFile.contents.toString(),
'name': slug,
'slug': slug,
'i18n_type': 'XLIFF'
});
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resources`,
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(data)
},
auth: credentials,
method: 'POST'
};
let request = https.request(options, (res) => {
if (res.statusCode === 201) {
log(`Resource ${project}/${slug} successfully created on Transifex.`);
}
else {
reject(`Something went wrong in the request creating ${slug} in ${project}. ${res.statusCode}`);
}
});
request.on('error', (err) => {
reject(`Failed to create ${project}/${slug} on Transifex: ${err}`);
});
request.write(data);
request.end();
});
}
/**
* The following link provides information about how Transifex handles updates of a resource file:
* https://dev.befoolish.co/tx-docs/public/projects/updating-content#what-happens-when-you-update-files
*/
function updateResource(project, slug, xlfFile, apiHostname, credentials) {
return new Promise((resolve, reject) => {
const data = JSON.stringify({ content: xlfFile.contents.toString() });
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/content`,
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(data)
},
auth: credentials,
method: 'PUT'
};
let request = https.request(options, (res) => {
if (res.statusCode === 200) {
res.setEncoding('utf8');
let responseBuffer = '';
res.on('data', function (chunk) {
responseBuffer += chunk;
});
res.on('end', () => {
const response = JSON.parse(responseBuffer);
log(`Resource ${project}/${slug} successfully updated on Transifex. Strings added: ${response.strings_added}, updated: ${response.strings_added}, deleted: ${response.strings_added}`);
resolve();
});
}
else {
reject(`Something went wrong in the request updating ${slug} in ${project}. ${res.statusCode}`);
}
});
request.on('error', (err) => {
reject(`Failed to update ${project}/${slug} on Transifex: ${err}`);
});
request.write(data);
request.end();
});
}
// cache resources
let _coreAndExtensionResources;
function pullCoreAndExtensionsXlfFiles(apiHostname, username, password, language, externalExtensions) {
if (!_coreAndExtensionResources) {
_coreAndExtensionResources = [];
// editor and workbench
const json = JSON.parse(fs.readFileSync('./build/lib/i18n.resources.json', 'utf8'));
_coreAndExtensionResources.push(...json.editor);
_coreAndExtensionResources.push(...json.workbench);
// extensions
let extensionsToLocalize = Object.create(null);
glob.sync('.build/extensions/**/*.nls.json').forEach(extension => extensionsToLocalize[extension.split('/')[2]] = true);
glob.sync('.build/extensions/*/node_modules/vscode-nls').forEach(extension => extensionsToLocalize[extension.split('/')[2]] = true);
Object.keys(extensionsToLocalize).forEach(extension => {
_coreAndExtensionResources.push({ name: extension, project: extensionsProject });
});
if (externalExtensions) {
for (let resourceName in externalExtensions) {
_coreAndExtensionResources.push({ name: resourceName, project: extensionsProject });
}
}
}
return pullXlfFiles(apiHostname, username, password, language, _coreAndExtensionResources);
}
exports.pullCoreAndExtensionsXlfFiles = pullCoreAndExtensionsXlfFiles;
function pullSetupXlfFiles(apiHostname, username, password, language, includeDefault) {
let setupResources = [{ name: 'setup_messages', project: workbenchProject }];
if (includeDefault) {
setupResources.push({ name: 'setup_default', project: setupProject });
}
return pullXlfFiles(apiHostname, username, password, language, setupResources);
}
exports.pullSetupXlfFiles = pullSetupXlfFiles;
function pullXlfFiles(apiHostname, username, password, language, resources) {
const credentials = `${username}:${password}`;
let expectedTranslationsCount = resources.length;
let translationsRetrieved = 0, called = false;
return event_stream_1.readable(function (_count, callback) {
// Mark end of stream when all resources were retrieved
if (translationsRetrieved === expectedTranslationsCount) {
return this.emit('end');
}
if (!called) {
called = true;
const stream = this;
resources.map(function (resource) {
retrieveResource(language, resource, apiHostname, credentials).then((file) => {
if (file) {
stream.emit('data', file);
}
translationsRetrieved++;
}).catch(error => { throw new Error(error); });
});
}
callback();
});
}
const limiter = new Limiter(NUMBER_OF_CONCURRENT_DOWNLOADS);
function retrieveResource(language, resource, apiHostname, credentials) {
return limiter.queue(() => new Promise((resolve, reject) => {
const slug = resource.name.replace(/\//g, '_');
const project = resource.project;
let transifexLanguageId = language.id === 'ps' ? 'en' : language.translationId || language.id;
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/translation/${transifexLanguageId}?file&mode=onlyreviewed`,
auth: credentials,
port: 443,
method: 'GET'
};
console.log('[transifex] Fetching ' + options.path);
let request = https.request(options, (res) => {
let xlfBuffer = [];
res.on('data', (chunk) => xlfBuffer.push(chunk));
res.on('end', () => {
if (res.statusCode === 200) {
resolve(new File({ contents: Buffer.concat(xlfBuffer), path: `${project}/${slug}.xlf` }));
}
else if (res.statusCode === 404) {
console.log(`[transifex] ${slug} in ${project} returned no data.`);
resolve(null);
}
else {
reject(`${slug} in ${project} returned no data. Response code: ${res.statusCode}.`);
}
});
});
request.on('error', (err) => {
reject(`Failed to query resource ${slug} with the following error: ${err}. ${options.path}`);
});
request.end();
}));
}
function prepareI18nFiles() {
let parsePromises = [];
return event_stream_1.through(function (xlf) {
let stream = this;
let parsePromise = XLF.parse(xlf.contents.toString());
parsePromises.push(parsePromise);
parsePromise.then(resolvedFiles => {
resolvedFiles.forEach(file => {
let translatedFile = createI18nFile(file.originalFilePath, file.messages);
stream.queue(translatedFile);
});
});
}, function () {
Promise.all(parsePromises)
.then(() => { this.queue(null); })
.catch(reason => { throw new Error(reason); });
});
}
exports.prepareI18nFiles = prepareI18nFiles;
function createI18nFile(originalFilePath, messages) {
let result = Object.create(null);
result[''] = [
'--------------------------------------------------------------------------------------------',
'Copyright (c) Microsoft Corporation. All rights reserved.',
'Licensed under the MIT License. See License.txt in the project root for license information.',
'--------------------------------------------------------------------------------------------',
'Do not edit this file. It is machine generated.'
];
for (let key of Object.keys(messages)) {
result[key] = messages[key];
}
let content = JSON.stringify(result, null, '\t');
if (process.platform === 'win32') {
content = content.replace(/\n/g, '\r\n');
}
return new File({
path: path.join(originalFilePath + '.i18n.json'),
contents: Buffer.from(content, 'utf8')
});
}
const i18nPackVersion = "1.0.0";
function pullI18nPackFiles(apiHostname, username, password, language, resultingTranslationPaths) {
return pullCoreAndExtensionsXlfFiles(apiHostname, username, password, language, exports.externalExtensionsWithTranslations)
.pipe(prepareI18nPackFiles(exports.externalExtensionsWithTranslations, resultingTranslationPaths, language.id === 'ps'));
}
exports.pullI18nPackFiles = pullI18nPackFiles;
function prepareI18nPackFiles(externalExtensions, resultingTranslationPaths, pseudo = false) {
let parsePromises = [];
let mainPack = { version: i18nPackVersion, contents: {} };
let extensionsPacks = {};
let errors = [];
return event_stream_1.through(function (xlf) {
let project = path.basename(path.dirname(xlf.relative));
let resource = path.basename(xlf.relative, '.xlf');
let contents = xlf.contents.toString();
let parsePromise = pseudo ? XLF.parsePseudo(contents) : XLF.parse(contents);
parsePromises.push(parsePromise);
parsePromise.then(resolvedFiles => {
resolvedFiles.forEach(file => {
const path = file.originalFilePath;
const firstSlash = path.indexOf('/');
if (project === extensionsProject) {
let extPack = extensionsPacks[resource];
if (!extPack) {
extPack = extensionsPacks[resource] = { version: i18nPackVersion, contents: {} };
}
const externalId = externalExtensions[resource];
if (!externalId) { // internal extension: remove 'extensions/extensionId/' segnent
const secondSlash = path.indexOf('/', firstSlash + 1);
extPack.contents[path.substr(secondSlash + 1)] = file.messages;
}
else {
extPack.contents[path] = file.messages;
}
}
else {
mainPack.contents[path.substr(firstSlash + 1)] = file.messages;
}
});
}).catch(reason => {
errors.push(reason);
});
}, function () {
Promise.all(parsePromises)
.then(() => {
if (errors.length > 0) {
throw errors;
}
const translatedMainFile = createI18nFile('./main', mainPack);
resultingTranslationPaths.push({ id: 'vscode', resourceName: 'main.i18n.json' });
this.queue(translatedMainFile);
for (let extension in extensionsPacks) {
const translatedExtFile = createI18nFile(`extensions/${extension}`, extensionsPacks[extension]);
this.queue(translatedExtFile);
const externalExtensionId = externalExtensions[extension];
if (externalExtensionId) {
resultingTranslationPaths.push({ id: externalExtensionId, resourceName: `extensions/${extension}.i18n.json` });
}
else {
resultingTranslationPaths.push({ id: `vscode.${extension}`, resourceName: `extensions/${extension}.i18n.json` });
}
}
this.queue(null);
})
.catch((reason) => {
this.emit('error', reason);
});
});
}
exports.prepareI18nPackFiles = prepareI18nPackFiles;
function prepareIslFiles(language, innoSetupConfig) {
let parsePromises = [];
return event_stream_1.through(function (xlf) {
let stream = this;
let parsePromise = XLF.parse(xlf.contents.toString());
parsePromises.push(parsePromise);
parsePromise.then(resolvedFiles => {
resolvedFiles.forEach(file => {
if (path.basename(file.originalFilePath) === 'Default' && !innoSetupConfig.defaultInfo) {
return;
}
let translatedFile = createIslFile(file.originalFilePath, file.messages, language, innoSetupConfig);
stream.queue(translatedFile);
});
}).catch(reason => {
this.emit('error', reason);
});
}, function () {
Promise.all(parsePromises)
.then(() => { this.queue(null); })
.catch(reason => {
this.emit('error', reason);
});
});
}
exports.prepareIslFiles = prepareIslFiles;
function createIslFile(originalFilePath, messages, language, innoSetup) {
let content = [];
let originalContent;
if (path.basename(originalFilePath) === 'Default') {
originalContent = new TextModel(fs.readFileSync(originalFilePath + '.isl', 'utf8'));
}
else {
originalContent = new TextModel(fs.readFileSync(originalFilePath + '.en.isl', 'utf8'));
}
originalContent.lines.forEach(line => {
if (line.length > 0) {
let firstChar = line.charAt(0);
if (firstChar === '[' || firstChar === ';') {
if (line === '; *** Inno Setup version 5.5.3+ English messages ***') {
content.push(`; *** Inno Setup version 5.5.3+ ${innoSetup.defaultInfo.name} messages ***`);
}
else {
content.push(line);
}
}
else {
let sections = line.split('=');
let key = sections[0];
let translated = line;
if (key) {
if (key === 'LanguageName') {
translated = `${key}=${innoSetup.defaultInfo.name}`;
}
else if (key === 'LanguageID') {
translated = `${key}=${innoSetup.defaultInfo.id}`;
}
else if (key === 'LanguageCodePage') {
translated = `${key}=${innoSetup.codePage.substr(2)}`;
}
else {
let translatedMessage = messages[key];
if (translatedMessage) {
translated = `${key}=${translatedMessage}`;
}
}
}
content.push(translated);
}
}
});
const basename = path.basename(originalFilePath);
const filePath = `${basename}.${language.id}.isl`;
return new File({
path: filePath,
contents: iconv.encode(Buffer.from(content.join('\r\n'), 'utf8').toString(), innoSetup.codePage)
});
}
function encodeEntities(value) {
let result = [];
for (let i = 0; i < value.length; i++) {
let ch = value[i];
switch (ch) {
case '<':
result.push('<');
break;
case '>':
result.push('>');
break;
case '&':
result.push('&');
break;
default:
result.push(ch);
}
}
return result.join('');
}
function decodeEntities(value) {
return value.replace(/</g, '<').replace(/>/g, '>').replace(/&/g, '&');
}
function pseudify(message) {
return '\uFF3B' + message.replace(/[aouei]/g, '$&$&') + '\uFF3D';
}
================================================
FILE: build/lib/i18n.resources.json
================================================
{
"editor": [
{
"name": "vs/platform",
"project": "vscode-editor"
},
{
"name": "vs/editor/contrib",
"project": "vscode-editor"
},
{
"name": "vs/editor",
"project": "vscode-editor"
},
{
"name": "vs/base",
"project": "vscode-editor"
}
],
"workbench": [
{
"name": "vs/code",
"project": "vscode-workbench"
},
{
"name": "vs/workbench",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/api/common",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/cli",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/codeEditor",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/callHierarchy",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/comments",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/debug",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/emmet",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/extensions",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/externalTerminal",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/feedback",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/files",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/html",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/issue",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/markers",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/localizations",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/logs",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/output",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/performance",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/preferences",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/quickopen",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/userData",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/remote",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/relauncher",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/scm",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/search",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/snippets",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/format",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/stats",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/surveys",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/tasks",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/terminal",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/themes",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/trust",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/update",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/url",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/watermark",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/webview",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/customEditor",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/welcome",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/outline",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/contrib/userDataSync",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/actions",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/bulkEdit",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/commands",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/configuration",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/configurationResolver",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/crashReporter",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/dialogs",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/editor",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/extensions",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/extensionManagement",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/files",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/integrity",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/keybinding",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/lifecycle",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/mode",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/progress",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/remote",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/textfile",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/themes",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/textMate",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/workspaces",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/decorations",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/label",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/preferences",
"project": "vscode-preferences"
},
{
"name": "vs/workbench/services/notification",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/services/userData",
"project": "vscode-workbench"
},
{
"name": "vs/workbench/parts/maix",
"project": "maix-extension"
}
]
}
================================================
FILE: build/lib/i18n.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as path from 'path';
import * as fs from 'fs';
import { through, readable, ThroughStream } from 'event-stream';
import * as File from 'vinyl';
import * as Is from 'is';
import * as xml2js from 'xml2js';
import * as glob from 'glob';
import * as https from 'https';
import * as gulp from 'gulp';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
import * as iconv from 'iconv-lite';
const NUMBER_OF_CONCURRENT_DOWNLOADS = 4;
function log(message: any, ...rest: any[]): void {
fancyLog(ansiColors.green('[i18n]'), message, ...rest);
}
export interface Language {
id: string; // language id, e.g. zh-tw, de
translationId?: string; // language id used in translation tools, e.g. zh-hant, de (optional, if not set, the id is used)
folderName?: string; // language specific folder name, e.g. cht, deu (optional, if not set, the id is used)
}
export interface InnoSetup {
codePage: string; //code page for encoding (http://www.jrsoftware.org/ishelp/index.php?topic=langoptionssection)
defaultInfo?: {
name: string; // inno setup language name
id: string; // locale identifier (https://msdn.microsoft.com/en-us/library/dd318693.aspx)
};
}
export const defaultLanguages: Language[] = [
{ id: 'zh-tw', folderName: 'cht', translationId: 'zh-hant' },
{ id: 'zh-cn', folderName: 'chs', translationId: 'zh-hans' },
{ id: 'ja', folderName: 'jpn' },
{ id: 'ko', folderName: 'kor' },
{ id: 'de', folderName: 'deu' },
{ id: 'fr', folderName: 'fra' },
{ id: 'es', folderName: 'esn' },
{ id: 'ru', folderName: 'rus' },
{ id: 'it', folderName: 'ita' }
];
// languages requested by the community to non-stable builds
export const extraLanguages: Language[] = [
{ id: 'pt-br', folderName: 'ptb' },
{ id: 'hu', folderName: 'hun' },
{ id: 'tr', folderName: 'trk' }
];
// non built-in extensions also that are transifex and need to be part of the language packs
export const externalExtensionsWithTranslations = {
'vscode-chrome-debug': 'msjsdiag.debugger-for-chrome',
'vscode-node-debug': 'ms-vscode.node-debug',
'vscode-node-debug2': 'ms-vscode.node-debug2'
};
interface Map {
[key: string]: V;
}
interface Item {
id: string;
message: string;
comment?: string;
}
export interface Resource {
name: string;
project: string;
}
interface ParsedXLF {
messages: Map;
originalFilePath: string;
language: string;
}
interface LocalizeInfo {
key: string;
comment: string[];
}
module LocalizeInfo {
export function is(value: any): value is LocalizeInfo {
let candidate = value as LocalizeInfo;
return Is.defined(candidate) && Is.string(candidate.key) && (Is.undef(candidate.comment) || (Is.array(candidate.comment) && candidate.comment.every(element => Is.string(element))));
}
}
interface BundledFormat {
keys: Map<(string | LocalizeInfo)[]>;
messages: Map;
bundles: Map;
}
module BundledFormat {
export function is(value: any): value is BundledFormat {
if (Is.undef(value)) {
return false;
}
let candidate = value as BundledFormat;
let length = Object.keys(value).length;
return length === 3 && Is.defined(candidate.keys) && Is.defined(candidate.messages) && Is.defined(candidate.bundles);
}
}
interface ValueFormat {
message: string;
comment: string[];
}
interface PackageJsonFormat {
[key: string]: string | ValueFormat;
}
module PackageJsonFormat {
export function is(value: any): value is PackageJsonFormat {
if (Is.undef(value) || !Is.object(value)) {
return false;
}
return Object.keys(value).every(key => {
let element = value[key];
return Is.string(element) || (Is.object(element) && Is.defined(element.message) && Is.defined(element.comment));
});
}
}
interface BundledExtensionFormat {
[key: string]: {
messages: string[];
keys: (string | LocalizeInfo)[];
};
}
interface I18nFormat {
version: string;
contents: {
[module: string]: {
[messageKey: string]: string;
};
};
}
export class Line {
private buffer: string[] = [];
constructor(indent: number = 0) {
if (indent > 0) {
this.buffer.push(new Array(indent + 1).join(' '));
}
}
public append(value: string): Line {
this.buffer.push(value);
return this;
}
public toString(): string {
return this.buffer.join('');
}
}
class TextModel {
private _lines: string[];
constructor(contents: string) {
this._lines = contents.split(/\r\n|\r|\n/);
}
public get lines(): string[] {
return this._lines;
}
}
export class XLF {
private buffer: string[];
private files: Map;
public numberOfMessages: number;
constructor(public project: string) {
this.buffer = [];
this.files = Object.create(null);
this.numberOfMessages = 0;
}
public toString(): string {
this.appendHeader();
for (let file in this.files) {
this.appendNewLine(``, 2);
for (let item of this.files[file]) {
this.addStringItem(item);
}
this.appendNewLine('', 2);
}
this.appendFooter();
return this.buffer.join('\r\n');
}
public addFile(original: string, keys: (string | LocalizeInfo)[], messages: string[]) {
if (keys.length === 0) {
console.log('No keys in ' + original);
return;
}
if (keys.length !== messages.length) {
throw new Error(`Unmatching keys(${keys.length}) and messages(${messages.length}).`);
}
this.numberOfMessages += keys.length;
this.files[original] = [];
let existingKeys = new Set();
for (let i = 0; i < keys.length; i++) {
let key = keys[i];
let realKey: string | undefined;
let comment: string | undefined;
if (Is.string(key)) {
realKey = key;
comment = undefined;
} else if (LocalizeInfo.is(key)) {
realKey = key.key;
if (key.comment && key.comment.length > 0) {
comment = key.comment.map(comment => encodeEntities(comment)).join('\r\n');
}
}
if (!realKey || existingKeys.has(realKey)) {
continue;
}
existingKeys.add(realKey);
let message: string = encodeEntities(messages[i]);
this.files[original].push({ id: realKey, message: message, comment: comment });
}
}
private addStringItem(item: Item): void {
if (!item.id || !item.message) {
throw new Error(`No item ID or value specified: ${JSON.stringify(item)}`);
}
this.appendNewLine(``, 4);
this.appendNewLine(`${item.message}`, 6);
if (item.comment) {
this.appendNewLine(`${item.comment}`, 6);
}
this.appendNewLine('', 4);
}
private appendHeader(): void {
this.appendNewLine('', 0);
this.appendNewLine('', 0);
}
private appendFooter(): void {
this.appendNewLine('', 0);
}
private appendNewLine(content: string, indent?: number): void {
let line = new Line(indent);
line.append(content);
this.buffer.push(line.toString());
}
static parsePseudo = function (xlfString: string): Promise {
return new Promise((resolve) => {
let parser = new xml2js.Parser();
let files: { messages: Map, originalFilePath: string, language: string }[] = [];
parser.parseString(xlfString, function (_err: any, result: any) {
const fileNodes: any[] = result['xliff']['file'];
fileNodes.forEach(file => {
const originalFilePath = file.$.original;
const messages: Map = {};
const transUnits = file.body[0]['trans-unit'];
if (transUnits) {
transUnits.forEach((unit: any) => {
const key = unit.$.id;
const val = pseudify(unit.source[0]['_'].toString());
if (key && val) {
messages[key] = decodeEntities(val);
}
});
files.push({ messages: messages, originalFilePath: originalFilePath, language: 'ps' });
}
});
resolve(files);
});
});
};
static parse = function (xlfString: string): Promise {
return new Promise((resolve, reject) => {
let parser = new xml2js.Parser();
let files: { messages: Map, originalFilePath: string, language: string }[] = [];
parser.parseString(xlfString, function (err: any, result: any) {
if (err) {
reject(new Error(`XLF parsing error: Failed to parse XLIFF string. ${err}`));
}
const fileNodes: any[] = result['xliff']['file'];
if (!fileNodes) {
reject(new Error(`XLF parsing error: XLIFF file does not contain "xliff" or "file" node(s) required for parsing.`));
}
fileNodes.forEach((file) => {
const originalFilePath = file.$.original;
if (!originalFilePath) {
reject(new Error(`XLF parsing error: XLIFF file node does not contain original attribute to determine the original location of the resource file.`));
}
let language = file.$['target-language'];
if (!language) {
reject(new Error(`XLF parsing error: XLIFF file node does not contain target-language attribute to determine translated language.`));
}
const messages: Map = {};
const transUnits = file.body[0]['trans-unit'];
if (transUnits) {
transUnits.forEach((unit: any) => {
const key = unit.$.id;
if (!unit.target) {
return; // No translation available
}
let val = unit.target[0];
if (typeof val !== 'string') {
val = val._;
}
if (key && val) {
messages[key] = decodeEntities(val);
} else {
reject(new Error(`XLF parsing error: XLIFF file ${originalFilePath} does not contain full localization data. ID or target translation for one of the trans-unit nodes is not present.`));
}
});
files.push({ messages: messages, originalFilePath: originalFilePath, language: language.toLowerCase() });
}
});
resolve(files);
});
});
};
}
export interface ITask {
(): T;
}
interface ILimitedTaskFactory {
factory: ITask>;
c: (value?: T | Promise) => void;
e: (error?: any) => void;
}
export class Limiter {
private runningPromises: number;
private outstandingPromises: ILimitedTaskFactory[];
constructor(private maxDegreeOfParalellism: number) {
this.outstandingPromises = [];
this.runningPromises = 0;
}
queue(factory: ITask>): Promise {
return new Promise((c, e) => {
this.outstandingPromises.push({ factory, c, e });
this.consume();
});
}
private consume(): void {
while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
const iLimitedTask = this.outstandingPromises.shift()!;
this.runningPromises++;
const promise = iLimitedTask.factory();
promise.then(iLimitedTask.c).catch(iLimitedTask.e);
promise.then(() => this.consumed()).catch(() => this.consumed());
}
}
private consumed(): void {
this.runningPromises--;
this.consume();
}
}
function sortLanguages(languages: Language[]): Language[] {
return languages.sort((a: Language, b: Language): number => {
return a.id < b.id ? -1 : (a.id > b.id ? 1 : 0);
});
}
function stripComments(content: string): string {
/**
* First capturing group matches double quoted string
* Second matches single quotes string
* Third matches block comments
* Fourth matches line comments
*/
const regexp = /("(?:[^\\\"]*(?:\\.)?)*")|('(?:[^\\\']*(?:\\.)?)*')|(\/\*(?:\r?\n|.)*?\*\/)|(\/{2,}.*?(?:(?:\r?\n)|$))/g;
let result = content.replace(regexp, (match, _m1, _m2, m3, m4) => {
// Only one of m1, m2, m3, m4 matches
if (m3) {
// A block comment. Replace with nothing
return '';
} else if (m4) {
// A line comment. If it ends in \r?\n then keep it.
let length = m4.length;
if (length > 2 && m4[length - 1] === '\n') {
return m4[length - 2] === '\r' ? '\r\n' : '\n';
} else {
return '';
}
} else {
// We match a string
return match;
}
});
return result;
}
function escapeCharacters(value: string): string {
const result: string[] = [];
for (let i = 0; i < value.length; i++) {
const ch = value.charAt(i);
switch (ch) {
case '\'':
result.push('\\\'');
break;
case '"':
result.push('\\"');
break;
case '\\':
result.push('\\\\');
break;
case '\n':
result.push('\\n');
break;
case '\r':
result.push('\\r');
break;
case '\t':
result.push('\\t');
break;
case '\b':
result.push('\\b');
break;
case '\f':
result.push('\\f');
break;
default:
result.push(ch);
}
}
return result.join('');
}
function processCoreBundleFormat(fileHeader: string, languages: Language[], json: BundledFormat, emitter: ThroughStream) {
let keysSection = json.keys;
let messageSection = json.messages;
let bundleSection = json.bundles;
let statistics: Map = Object.create(null);
let defaultMessages: Map> = Object.create(null);
let modules = Object.keys(keysSection);
modules.forEach((module) => {
let keys = keysSection[module];
let messages = messageSection[module];
if (!messages || keys.length !== messages.length) {
emitter.emit('error', `Message for module ${module} corrupted. Mismatch in number of keys and messages.`);
return;
}
let messageMap: Map = Object.create(null);
defaultMessages[module] = messageMap;
keys.map((key, i) => {
if (typeof key === 'string') {
messageMap[key] = messages[i];
} else {
messageMap[key.key] = messages[i];
}
});
});
let languageDirectory = path.join(__dirname, '..', '..', '..', 'vscode-loc', 'i18n');
if (!fs.existsSync(languageDirectory)) {
log(`No VS Code localization repository found. Looking at ${languageDirectory}`);
log(`To bundle translations please check out the vscode-loc repository as a sibling of the vscode repository.`);
}
let sortedLanguages = sortLanguages(languages);
sortedLanguages.forEach((language) => {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`Generating nls bundles for: ${language.id}`);
}
statistics[language.id] = 0;
let localizedModules: Map = Object.create(null);
let languageFolderName = language.translationId || language.id;
let i18nFile = path.join(languageDirectory, `vscode-language-pack-${languageFolderName}`, 'translations', 'main.i18n.json');
let allMessages: I18nFormat | undefined;
if (fs.existsSync(i18nFile)) {
let content = stripComments(fs.readFileSync(i18nFile, 'utf8'));
allMessages = JSON.parse(content);
}
modules.forEach((module) => {
let order = keysSection[module];
let moduleMessage: { [messageKey: string]: string } | undefined;
if (allMessages) {
moduleMessage = allMessages.contents[module];
}
if (!moduleMessage) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`No localized messages found for module ${module}. Using default messages.`);
}
moduleMessage = defaultMessages[module];
statistics[language.id] = statistics[language.id] + Object.keys(moduleMessage).length;
}
let localizedMessages: string[] = [];
order.forEach((keyInfo) => {
let key: string | null = null;
if (typeof keyInfo === 'string') {
key = keyInfo;
} else {
key = keyInfo.key;
}
let message: string = moduleMessage![key];
if (!message) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log(`No localized message found for key ${key} in module ${module}. Using default message.`);
}
message = defaultMessages[module][key];
statistics[language.id] = statistics[language.id] + 1;
}
localizedMessages.push(message);
});
localizedModules[module] = localizedMessages;
});
Object.keys(bundleSection).forEach((bundle) => {
let modules = bundleSection[bundle];
let contents: string[] = [
fileHeader,
`define("${bundle}.nls.${language.id}", {`
];
modules.forEach((module, index) => {
contents.push(`\t"${module}": [`);
let messages = localizedModules[module];
if (!messages) {
emitter.emit('error', `Didn't find messages for module ${module}.`);
return;
}
messages.forEach((message, index) => {
contents.push(`\t\t"${escapeCharacters(message)}${index < messages.length ? '",' : '"'}`);
});
contents.push(index < modules.length - 1 ? '\t],' : '\t]');
});
contents.push('});');
emitter.queue(new File({ path: bundle + '.nls.' + language.id + '.js', contents: Buffer.from(contents.join('\n'), 'utf-8') }));
});
});
Object.keys(statistics).forEach(key => {
let value = statistics[key];
log(`${key} has ${value} untranslated strings.`);
});
sortedLanguages.forEach(language => {
let stats = statistics[language.id];
if (Is.undef(stats)) {
log(`\tNo translations found for language ${language.id}. Using default language instead.`);
}
});
}
export function processNlsFiles(opts: { fileHeader: string; languages: Language[] }): ThroughStream {
return through(function (this: ThroughStream, file: File) {
let fileName = path.basename(file.path);
if (fileName === 'nls.metadata.json') {
let json = null;
if (file.isBuffer()) {
json = JSON.parse((file.contents).toString('utf8'));
} else {
this.emit('error', `Failed to read component file: ${file.relative}`);
return;
}
if (BundledFormat.is(json)) {
processCoreBundleFormat(opts.fileHeader, opts.languages, json, this);
}
}
this.queue(file);
});
}
const editorProject: string = 'vscode-editor',
workbenchProject: string = 'vscode-workbench',
extensionsProject: string = 'vscode-extensions',
setupProject: string = 'vscode-setup';
export function getResource(sourceFile: string): Resource {
let resource: string;
if (/^vs\/platform/.test(sourceFile)) {
return { name: 'vs/platform', project: editorProject };
} else if (/^vs\/editor\/contrib/.test(sourceFile)) {
return { name: 'vs/editor/contrib', project: editorProject };
} else if (/^vs\/editor/.test(sourceFile)) {
return { name: 'vs/editor', project: editorProject };
} else if (/^vs\/base/.test(sourceFile)) {
return { name: 'vs/base', project: editorProject };
} else if (/^vs\/code/.test(sourceFile)) {
return { name: 'vs/code', project: workbenchProject };
} else if (/^vs\/workbench\/contrib/.test(sourceFile)) {
resource = sourceFile.split('/', 4).join('/');
return { name: resource, project: workbenchProject };
} else if (/^vs\/workbench\/services/.test(sourceFile)) {
resource = sourceFile.split('/', 4).join('/');
return { name: resource, project: workbenchProject };
} else if (/^vs\/workbench/.test(sourceFile)) {
return { name: 'vs/workbench', project: workbenchProject };
}
throw new Error(`Could not identify the XLF bundle for ${sourceFile}`);
}
export function createXlfFilesForCoreBundle(): ThroughStream {
return through(function (this: ThroughStream, file: File) {
const basename = path.basename(file.path);
if (basename === 'nls.metadata.json') {
if (file.isBuffer()) {
const xlfs: Map = Object.create(null);
const json: BundledFormat = JSON.parse((file.contents as Buffer).toString('utf8'));
for (let coreModule in json.keys) {
const projectResource = getResource(coreModule);
const resource = projectResource.name;
const project = projectResource.project;
const keys = json.keys[coreModule];
const messages = json.messages[coreModule];
if (keys.length !== messages.length) {
this.emit('error', `There is a mismatch between keys and messages in ${file.relative} for module ${coreModule}`);
return;
} else {
let xlf = xlfs[resource];
if (!xlf) {
xlf = new XLF(project);
xlfs[resource] = xlf;
}
xlf.addFile(`src/${coreModule}`, keys, messages);
}
}
for (let resource in xlfs) {
const xlf = xlfs[resource];
const filePath = `${xlf.project}/${resource.replace(/\//g, '_')}.xlf`;
const xlfFile = new File({
path: filePath,
contents: Buffer.from(xlf.toString(), 'utf8')
});
this.queue(xlfFile);
}
} else {
this.emit('error', new Error(`File ${file.relative} is not using a buffer content`));
return;
}
} else {
this.emit('error', new Error(`File ${file.relative} is not a core meta data file.`));
return;
}
});
}
export function createXlfFilesForExtensions(): ThroughStream {
let counter: number = 0;
let folderStreamEnded: boolean = false;
let folderStreamEndEmitted: boolean = false;
return through(function (this: ThroughStream, extensionFolder: File) {
const folderStream = this;
const stat = fs.statSync(extensionFolder.path);
if (!stat.isDirectory()) {
return;
}
let extensionName = path.basename(extensionFolder.path);
if (extensionName === 'node_modules') {
return;
}
counter++;
let _xlf: XLF;
function getXlf() {
if (!_xlf) {
_xlf = new XLF(extensionsProject);
}
return _xlf;
}
gulp.src([`.build/extensions/${extensionName}/package.nls.json`, `.build/extensions/${extensionName}/**/nls.metadata.json`], { allowEmpty: true }).pipe(through(function (file: File) {
if (file.isBuffer()) {
const buffer: Buffer = file.contents as Buffer;
const basename = path.basename(file.path);
if (basename === 'package.nls.json') {
const json: PackageJsonFormat = JSON.parse(buffer.toString('utf8'));
const keys = Object.keys(json);
const messages = keys.map((key) => {
const value = json[key];
if (Is.string(value)) {
return value;
} else if (value) {
return value.message;
} else {
return `Unknown message for key: ${key}`;
}
});
getXlf().addFile(`extensions/${extensionName}/package`, keys, messages);
} else if (basename === 'nls.metadata.json') {
const json: BundledExtensionFormat = JSON.parse(buffer.toString('utf8'));
const relPath = path.relative(`.build/extensions/${extensionName}`, path.dirname(file.path));
for (let file in json) {
const fileContent = json[file];
getXlf().addFile(`extensions/${extensionName}/${relPath}/${file}`, fileContent.keys, fileContent.messages);
}
} else {
this.emit('error', new Error(`${file.path} is not a valid extension nls file`));
return;
}
}
}, function () {
if (_xlf) {
let xlfFile = new File({
path: path.join(extensionsProject, extensionName + '.xlf'),
contents: Buffer.from(_xlf.toString(), 'utf8')
});
folderStream.queue(xlfFile);
}
this.queue(null);
counter--;
if (counter === 0 && folderStreamEnded && !folderStreamEndEmitted) {
folderStreamEndEmitted = true;
folderStream.queue(null);
}
}));
}, function () {
folderStreamEnded = true;
if (counter === 0) {
folderStreamEndEmitted = true;
this.queue(null);
}
});
}
export function createXlfFilesForIsl(): ThroughStream {
return through(function (this: ThroughStream, file: File) {
let projectName: string,
resourceFile: string;
if (path.basename(file.path) === 'Default.isl') {
projectName = setupProject;
resourceFile = 'setup_default.xlf';
} else {
projectName = workbenchProject;
resourceFile = 'setup_messages.xlf';
}
let xlf = new XLF(projectName),
keys: string[] = [],
messages: string[] = [];
let model = new TextModel(file.contents.toString());
let inMessageSection = false;
model.lines.forEach(line => {
if (line.length === 0) {
return;
}
let firstChar = line.charAt(0);
switch (firstChar) {
case ';':
// Comment line;
return;
case '[':
inMessageSection = '[Messages]' === line || '[CustomMessages]' === line;
return;
}
if (!inMessageSection) {
return;
}
let sections: string[] = line.split('=');
if (sections.length !== 2) {
throw new Error(`Badly formatted message found: ${line}`);
} else {
let key = sections[0];
let value = sections[1];
if (key.length > 0 && value.length > 0) {
keys.push(key);
messages.push(value);
}
}
});
const originalPath = file.path.substring(file.cwd.length + 1, file.path.split('.')[0].length).replace(/\\/g, '/');
xlf.addFile(originalPath, keys, messages);
// Emit only upon all ISL files combined into single XLF instance
const newFilePath = path.join(projectName, resourceFile);
const xlfFile = new File({ path: newFilePath, contents: Buffer.from(xlf.toString(), 'utf-8') });
this.queue(xlfFile);
});
}
export function pushXlfFiles(apiHostname: string, username: string, password: string): ThroughStream {
let tryGetPromises: Array> = [];
let updateCreatePromises: Array> = [];
return through(function (this: ThroughStream, file: File) {
const project = path.dirname(file.relative);
const fileName = path.basename(file.path);
const slug = fileName.substr(0, fileName.length - '.xlf'.length);
const credentials = `${username}:${password}`;
// Check if resource already exists, if not, then create it.
let promise = tryGetResource(project, slug, apiHostname, credentials);
tryGetPromises.push(promise);
promise.then(exists => {
if (exists) {
promise = updateResource(project, slug, file, apiHostname, credentials);
} else {
promise = createResource(project, slug, file, apiHostname, credentials);
}
updateCreatePromises.push(promise);
});
}, function () {
// End the pipe only after all the communication with Transifex API happened
Promise.all(tryGetPromises).then(() => {
Promise.all(updateCreatePromises).then(() => {
this.queue(null);
}).catch((reason) => { throw new Error(reason); });
}).catch((reason) => { throw new Error(reason); });
});
}
function getAllResources(project: string, apiHostname: string, username: string, password: string): Promise {
return new Promise((resolve, reject) => {
const credentials = `${username}:${password}`;
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resources`,
auth: credentials,
method: 'GET'
};
const request = https.request(options, (res) => {
let buffer: Buffer[] = [];
res.on('data', (chunk: Buffer) => buffer.push(chunk));
res.on('end', () => {
if (res.statusCode === 200) {
let json = JSON.parse(Buffer.concat(buffer).toString());
if (Array.isArray(json)) {
resolve(json.map(o => o.slug));
return;
}
reject(`Unexpected data format. Response code: ${res.statusCode}.`);
} else {
reject(`No resources in ${project} returned no data. Response code: ${res.statusCode}.`);
}
});
});
request.on('error', (err) => {
reject(`Failed to query resources in ${project} with the following error: ${err}. ${options.path}`);
});
request.end();
});
}
export function findObsoleteResources(apiHostname: string, username: string, password: string): ThroughStream {
let resourcesByProject: Map = Object.create(null);
resourcesByProject[extensionsProject] = ([] as any[]).concat(externalExtensionsWithTranslations); // clone
return through(function (this: ThroughStream, file: File) {
const project = path.dirname(file.relative);
const fileName = path.basename(file.path);
const slug = fileName.substr(0, fileName.length - '.xlf'.length);
let slugs = resourcesByProject[project];
if (!slugs) {
resourcesByProject[project] = slugs = [];
}
slugs.push(slug);
this.push(file);
}, function () {
const json = JSON.parse(fs.readFileSync('./build/lib/i18n.resources.json', 'utf8'));
let i18Resources = [...json.editor, ...json.workbench].map((r: Resource) => r.project + '/' + r.name.replace(/\//g, '_'));
let extractedResources: string[] = [];
for (let project of [workbenchProject, editorProject]) {
for (let resource of resourcesByProject[project]) {
if (resource !== 'setup_messages') {
extractedResources.push(project + '/' + resource);
}
}
}
if (i18Resources.length !== extractedResources.length) {
console.log(`[i18n] Obsolete resources in file 'build/lib/i18n.resources.json': JSON.stringify(${i18Resources.filter(p => extractedResources.indexOf(p) === -1)})`);
console.log(`[i18n] Missing resources in file 'build/lib/i18n.resources.json': JSON.stringify(${extractedResources.filter(p => i18Resources.indexOf(p) === -1)})`);
}
let promises: Array> = [];
for (let project in resourcesByProject) {
promises.push(
getAllResources(project, apiHostname, username, password).then(resources => {
let expectedResources = resourcesByProject[project];
let unusedResources = resources.filter(resource => resource && expectedResources.indexOf(resource) === -1);
if (unusedResources.length) {
console.log(`[transifex] Obsolete resources in project '${project}': ${unusedResources.join(', ')}`);
}
})
);
}
return Promise.all(promises).then(_ => {
this.push(null);
}).catch((reason) => { throw new Error(reason); });
});
}
function tryGetResource(project: string, slug: string, apiHostname: string, credentials: string): Promise {
return new Promise((resolve, reject) => {
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/?details`,
auth: credentials,
method: 'GET'
};
const request = https.request(options, (response) => {
if (response.statusCode === 404) {
resolve(false);
} else if (response.statusCode === 200) {
resolve(true);
} else {
reject(`Failed to query resource ${project}/${slug}. Response: ${response.statusCode} ${response.statusMessage}`);
}
});
request.on('error', (err) => {
reject(`Failed to get ${project}/${slug} on Transifex: ${err}`);
});
request.end();
});
}
function createResource(project: string, slug: string, xlfFile: File, apiHostname: string, credentials: any): Promise {
return new Promise((_resolve, reject) => {
const data = JSON.stringify({
'content': xlfFile.contents.toString(),
'name': slug,
'slug': slug,
'i18n_type': 'XLIFF'
});
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resources`,
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(data)
},
auth: credentials,
method: 'POST'
};
let request = https.request(options, (res) => {
if (res.statusCode === 201) {
log(`Resource ${project}/${slug} successfully created on Transifex.`);
} else {
reject(`Something went wrong in the request creating ${slug} in ${project}. ${res.statusCode}`);
}
});
request.on('error', (err) => {
reject(`Failed to create ${project}/${slug} on Transifex: ${err}`);
});
request.write(data);
request.end();
});
}
/**
* The following link provides information about how Transifex handles updates of a resource file:
* https://dev.befoolish.co/tx-docs/public/projects/updating-content#what-happens-when-you-update-files
*/
function updateResource(project: string, slug: string, xlfFile: File, apiHostname: string, credentials: string): Promise {
return new Promise((resolve, reject) => {
const data = JSON.stringify({ content: xlfFile.contents.toString() });
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/content`,
headers: {
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(data)
},
auth: credentials,
method: 'PUT'
};
let request = https.request(options, (res) => {
if (res.statusCode === 200) {
res.setEncoding('utf8');
let responseBuffer: string = '';
res.on('data', function (chunk) {
responseBuffer += chunk;
});
res.on('end', () => {
const response = JSON.parse(responseBuffer);
log(`Resource ${project}/${slug} successfully updated on Transifex. Strings added: ${response.strings_added}, updated: ${response.strings_added}, deleted: ${response.strings_added}`);
resolve();
});
} else {
reject(`Something went wrong in the request updating ${slug} in ${project}. ${res.statusCode}`);
}
});
request.on('error', (err) => {
reject(`Failed to update ${project}/${slug} on Transifex: ${err}`);
});
request.write(data);
request.end();
});
}
// cache resources
let _coreAndExtensionResources: Resource[];
export function pullCoreAndExtensionsXlfFiles(apiHostname: string, username: string, password: string, language: Language, externalExtensions?: Map): NodeJS.ReadableStream {
if (!_coreAndExtensionResources) {
_coreAndExtensionResources = [];
// editor and workbench
const json = JSON.parse(fs.readFileSync('./build/lib/i18n.resources.json', 'utf8'));
_coreAndExtensionResources.push(...json.editor);
_coreAndExtensionResources.push(...json.workbench);
// extensions
let extensionsToLocalize = Object.create(null);
glob.sync('.build/extensions/**/*.nls.json').forEach(extension => extensionsToLocalize[extension.split('/')[2]] = true);
glob.sync('.build/extensions/*/node_modules/vscode-nls').forEach(extension => extensionsToLocalize[extension.split('/')[2]] = true);
Object.keys(extensionsToLocalize).forEach(extension => {
_coreAndExtensionResources.push({ name: extension, project: extensionsProject });
});
if (externalExtensions) {
for (let resourceName in externalExtensions) {
_coreAndExtensionResources.push({ name: resourceName, project: extensionsProject });
}
}
}
return pullXlfFiles(apiHostname, username, password, language, _coreAndExtensionResources);
}
export function pullSetupXlfFiles(apiHostname: string, username: string, password: string, language: Language, includeDefault: boolean): NodeJS.ReadableStream {
let setupResources = [{ name: 'setup_messages', project: workbenchProject }];
if (includeDefault) {
setupResources.push({ name: 'setup_default', project: setupProject });
}
return pullXlfFiles(apiHostname, username, password, language, setupResources);
}
function pullXlfFiles(apiHostname: string, username: string, password: string, language: Language, resources: Resource[]): NodeJS.ReadableStream {
const credentials = `${username}:${password}`;
let expectedTranslationsCount = resources.length;
let translationsRetrieved = 0, called = false;
return readable(function (_count: any, callback: any) {
// Mark end of stream when all resources were retrieved
if (translationsRetrieved === expectedTranslationsCount) {
return this.emit('end');
}
if (!called) {
called = true;
const stream = this;
resources.map(function (resource) {
retrieveResource(language, resource, apiHostname, credentials).then((file: File | null) => {
if (file) {
stream.emit('data', file);
}
translationsRetrieved++;
}).catch(error => { throw new Error(error); });
});
}
callback();
});
}
const limiter = new Limiter(NUMBER_OF_CONCURRENT_DOWNLOADS);
function retrieveResource(language: Language, resource: Resource, apiHostname: string, credentials: string): Promise {
return limiter.queue(() => new Promise((resolve, reject) => {
const slug = resource.name.replace(/\//g, '_');
const project = resource.project;
let transifexLanguageId = language.id === 'ps' ? 'en' : language.translationId || language.id;
const options = {
hostname: apiHostname,
path: `/api/2/project/${project}/resource/${slug}/translation/${transifexLanguageId}?file&mode=onlyreviewed`,
auth: credentials,
port: 443,
method: 'GET'
};
console.log('[transifex] Fetching ' + options.path);
let request = https.request(options, (res) => {
let xlfBuffer: Buffer[] = [];
res.on('data', (chunk: Buffer) => xlfBuffer.push(chunk));
res.on('end', () => {
if (res.statusCode === 200) {
resolve(new File({ contents: Buffer.concat(xlfBuffer), path: `${project}/${slug}.xlf` }));
} else if (res.statusCode === 404) {
console.log(`[transifex] ${slug} in ${project} returned no data.`);
resolve(null);
} else {
reject(`${slug} in ${project} returned no data. Response code: ${res.statusCode}.`);
}
});
});
request.on('error', (err) => {
reject(`Failed to query resource ${slug} with the following error: ${err}. ${options.path}`);
});
request.end();
}));
}
export function prepareI18nFiles(): ThroughStream {
let parsePromises: Promise[] = [];
return through(function (this: ThroughStream, xlf: File) {
let stream = this;
let parsePromise = XLF.parse(xlf.contents.toString());
parsePromises.push(parsePromise);
parsePromise.then(
resolvedFiles => {
resolvedFiles.forEach(file => {
let translatedFile = createI18nFile(file.originalFilePath, file.messages);
stream.queue(translatedFile);
});
}
);
}, function () {
Promise.all(parsePromises)
.then(() => { this.queue(null); })
.catch(reason => { throw new Error(reason); });
});
}
function createI18nFile(originalFilePath: string, messages: any): File {
let result = Object.create(null);
result[''] = [
'--------------------------------------------------------------------------------------------',
'Copyright (c) Microsoft Corporation. All rights reserved.',
'Licensed under the MIT License. See License.txt in the project root for license information.',
'--------------------------------------------------------------------------------------------',
'Do not edit this file. It is machine generated.'
];
for (let key of Object.keys(messages)) {
result[key] = messages[key];
}
let content = JSON.stringify(result, null, '\t');
if (process.platform === 'win32') {
content = content.replace(/\n/g, '\r\n');
}
return new File({
path: path.join(originalFilePath + '.i18n.json'),
contents: Buffer.from(content, 'utf8')
});
}
interface I18nPack {
version: string;
contents: {
[path: string]: Map;
};
}
const i18nPackVersion = "1.0.0";
export interface TranslationPath {
id: string;
resourceName: string;
}
export function pullI18nPackFiles(apiHostname: string, username: string, password: string, language: Language, resultingTranslationPaths: TranslationPath[]): NodeJS.ReadableStream {
return pullCoreAndExtensionsXlfFiles(apiHostname, username, password, language, externalExtensionsWithTranslations)
.pipe(prepareI18nPackFiles(externalExtensionsWithTranslations, resultingTranslationPaths, language.id === 'ps'));
}
export function prepareI18nPackFiles(externalExtensions: Map, resultingTranslationPaths: TranslationPath[], pseudo = false): NodeJS.ReadWriteStream {
let parsePromises: Promise[] = [];
let mainPack: I18nPack = { version: i18nPackVersion, contents: {} };
let extensionsPacks: Map = {};
let errors: any[] = [];
return through(function (this: ThroughStream, xlf: File) {
let project = path.basename(path.dirname(xlf.relative));
let resource = path.basename(xlf.relative, '.xlf');
let contents = xlf.contents.toString();
let parsePromise = pseudo ? XLF.parsePseudo(contents) : XLF.parse(contents);
parsePromises.push(parsePromise);
parsePromise.then(
resolvedFiles => {
resolvedFiles.forEach(file => {
const path = file.originalFilePath;
const firstSlash = path.indexOf('/');
if (project === extensionsProject) {
let extPack = extensionsPacks[resource];
if (!extPack) {
extPack = extensionsPacks[resource] = { version: i18nPackVersion, contents: {} };
}
const externalId = externalExtensions[resource];
if (!externalId) { // internal extension: remove 'extensions/extensionId/' segnent
const secondSlash = path.indexOf('/', firstSlash + 1);
extPack.contents[path.substr(secondSlash + 1)] = file.messages;
} else {
extPack.contents[path] = file.messages;
}
} else {
mainPack.contents[path.substr(firstSlash + 1)] = file.messages;
}
});
}
).catch(reason => {
errors.push(reason);
});
}, function () {
Promise.all(parsePromises)
.then(() => {
if (errors.length > 0) {
throw errors;
}
const translatedMainFile = createI18nFile('./main', mainPack);
resultingTranslationPaths.push({ id: 'vscode', resourceName: 'main.i18n.json' });
this.queue(translatedMainFile);
for (let extension in extensionsPacks) {
const translatedExtFile = createI18nFile(`extensions/${extension}`, extensionsPacks[extension]);
this.queue(translatedExtFile);
const externalExtensionId = externalExtensions[extension];
if (externalExtensionId) {
resultingTranslationPaths.push({ id: externalExtensionId, resourceName: `extensions/${extension}.i18n.json` });
} else {
resultingTranslationPaths.push({ id: `vscode.${extension}`, resourceName: `extensions/${extension}.i18n.json` });
}
}
this.queue(null);
})
.catch((reason) => {
this.emit('error', reason);
});
});
}
export function prepareIslFiles(language: Language, innoSetupConfig: InnoSetup): ThroughStream {
let parsePromises: Promise[] = [];
return through(function (this: ThroughStream, xlf: File) {
let stream = this;
let parsePromise = XLF.parse(xlf.contents.toString());
parsePromises.push(parsePromise);
parsePromise.then(
resolvedFiles => {
resolvedFiles.forEach(file => {
if (path.basename(file.originalFilePath) === 'Default' && !innoSetupConfig.defaultInfo) {
return;
}
let translatedFile = createIslFile(file.originalFilePath, file.messages, language, innoSetupConfig);
stream.queue(translatedFile);
});
}
).catch(reason => {
this.emit('error', reason);
});
}, function () {
Promise.all(parsePromises)
.then(() => { this.queue(null); })
.catch(reason => {
this.emit('error', reason);
});
});
}
function createIslFile(originalFilePath: string, messages: Map, language: Language, innoSetup: InnoSetup): File {
let content: string[] = [];
let originalContent: TextModel;
if (path.basename(originalFilePath) === 'Default') {
originalContent = new TextModel(fs.readFileSync(originalFilePath + '.isl', 'utf8'));
} else {
originalContent = new TextModel(fs.readFileSync(originalFilePath + '.en.isl', 'utf8'));
}
originalContent.lines.forEach(line => {
if (line.length > 0) {
let firstChar = line.charAt(0);
if (firstChar === '[' || firstChar === ';') {
if (line === '; *** Inno Setup version 5.5.3+ English messages ***') {
content.push(`; *** Inno Setup version 5.5.3+ ${innoSetup.defaultInfo!.name} messages ***`);
} else {
content.push(line);
}
} else {
let sections: string[] = line.split('=');
let key = sections[0];
let translated = line;
if (key) {
if (key === 'LanguageName') {
translated = `${key}=${innoSetup.defaultInfo!.name}`;
} else if (key === 'LanguageID') {
translated = `${key}=${innoSetup.defaultInfo!.id}`;
} else if (key === 'LanguageCodePage') {
translated = `${key}=${innoSetup.codePage.substr(2)}`;
} else {
let translatedMessage = messages[key];
if (translatedMessage) {
translated = `${key}=${translatedMessage}`;
}
}
}
content.push(translated);
}
}
});
const basename = path.basename(originalFilePath);
const filePath = `${basename}.${language.id}.isl`;
return new File({
path: filePath,
contents: iconv.encode(Buffer.from(content.join('\r\n'), 'utf8').toString(), innoSetup.codePage)
});
}
function encodeEntities(value: string): string {
let result: string[] = [];
for (let i = 0; i < value.length; i++) {
let ch = value[i];
switch (ch) {
case '<':
result.push('<');
break;
case '>':
result.push('>');
break;
case '&':
result.push('&');
break;
default:
result.push(ch);
}
}
return result.join('');
}
function decodeEntities(value: string): string {
return value.replace(/</g, '<').replace(/>/g, '>').replace(/&/g, '&');
}
function pseudify(message: string) {
return '\uFF3B' + message.replace(/[aouei]/g, '$&$&') + '\uFF3D';
}
================================================
FILE: build/lib/nls.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
const ts = require("typescript");
const lazy = require("lazy.js");
const event_stream_1 = require("event-stream");
const File = require("vinyl");
const sm = require("source-map");
const path = require("path");
var CollectStepResult;
(function (CollectStepResult) {
CollectStepResult[CollectStepResult["Yes"] = 0] = "Yes";
CollectStepResult[CollectStepResult["YesAndRecurse"] = 1] = "YesAndRecurse";
CollectStepResult[CollectStepResult["No"] = 2] = "No";
CollectStepResult[CollectStepResult["NoAndRecurse"] = 3] = "NoAndRecurse";
})(CollectStepResult || (CollectStepResult = {}));
function collect(node, fn) {
const result = [];
function loop(node) {
const stepResult = fn(node);
if (stepResult === CollectStepResult.Yes || stepResult === CollectStepResult.YesAndRecurse) {
result.push(node);
}
if (stepResult === CollectStepResult.YesAndRecurse || stepResult === CollectStepResult.NoAndRecurse) {
ts.forEachChild(node, loop);
}
}
loop(node);
return result;
}
function clone(object) {
const result = {};
for (const id in object) {
result[id] = object[id];
}
return result;
}
function template(lines) {
let indent = '', wrap = '';
if (lines.length > 1) {
indent = '\t';
wrap = '\n';
}
return `/*---------------------------------------------------------
* Copyright (C) Microsoft Corporation. All rights reserved.
*--------------------------------------------------------*/
define([], [${wrap + lines.map(l => indent + l).join(',\n') + wrap}]);`;
}
/**
* Returns a stream containing the patched JavaScript and source maps.
*/
function nls() {
const input = event_stream_1.through();
const output = input.pipe(event_stream_1.through(function (f) {
if (!f.sourceMap) {
return this.emit('error', new Error(`File ${f.relative} does not have sourcemaps.`));
}
let source = f.sourceMap.sources[0];
if (!source) {
return this.emit('error', new Error(`File ${f.relative} does not have a source in the source map.`));
}
const root = f.sourceMap.sourceRoot;
if (root) {
source = path.join(root, source);
}
const typescript = f.sourceMap.sourcesContent[0];
if (!typescript) {
return this.emit('error', new Error(`File ${f.relative} does not have the original content in the source map.`));
}
nls.patchFiles(f, typescript).forEach(f => this.emit('data', f));
}));
return event_stream_1.duplex(input, output);
}
function isImportNode(node) {
return node.kind === ts.SyntaxKind.ImportDeclaration || node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
}
(function (nls_1) {
function fileFrom(file, contents, path = file.path) {
return new File({
contents: Buffer.from(contents),
base: file.base,
cwd: file.cwd,
path: path
});
}
nls_1.fileFrom = fileFrom;
function mappedPositionFrom(source, lc) {
return { source, line: lc.line + 1, column: lc.character };
}
nls_1.mappedPositionFrom = mappedPositionFrom;
function lcFrom(position) {
return { line: position.line - 1, character: position.column };
}
nls_1.lcFrom = lcFrom;
class SingleFileServiceHost {
constructor(options, filename, contents) {
this.options = options;
this.filename = filename;
this.getCompilationSettings = () => this.options;
this.getScriptFileNames = () => [this.filename];
this.getScriptVersion = () => '1';
this.getScriptSnapshot = (name) => name === this.filename ? this.file : this.lib;
this.getCurrentDirectory = () => '';
this.getDefaultLibFileName = () => 'lib.d.ts';
this.file = ts.ScriptSnapshot.fromString(contents);
this.lib = ts.ScriptSnapshot.fromString('');
}
}
nls_1.SingleFileServiceHost = SingleFileServiceHost;
function isCallExpressionWithinTextSpanCollectStep(textSpan, node) {
if (!ts.textSpanContainsTextSpan({ start: node.pos, length: node.end - node.pos }, textSpan)) {
return CollectStepResult.No;
}
return node.kind === ts.SyntaxKind.CallExpression ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse;
}
function analyze(contents, options = {}) {
const filename = 'file.ts';
const serviceHost = new SingleFileServiceHost(Object.assign(clone(options), { noResolve: true }), filename, contents);
const service = ts.createLanguageService(serviceHost);
const sourceFile = ts.createSourceFile(filename, contents, ts.ScriptTarget.ES5, true);
// all imports
const imports = lazy(collect(sourceFile, n => isImportNode(n) ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse));
// import nls = require('vs/nls');
const importEqualsDeclarations = imports
.filter(n => n.kind === ts.SyntaxKind.ImportEqualsDeclaration)
.map(n => n)
.filter(d => d.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference)
.filter(d => d.moduleReference.expression.getText() === '\'vs/nls\'');
// import ... from 'vs/nls';
const importDeclarations = imports
.filter(n => n.kind === ts.SyntaxKind.ImportDeclaration)
.map(n => n)
.filter(d => d.moduleSpecifier.kind === ts.SyntaxKind.StringLiteral)
.filter(d => d.moduleSpecifier.getText() === '\'vs/nls\'')
.filter(d => !!d.importClause && !!d.importClause.namedBindings);
const nlsExpressions = importEqualsDeclarations
.map(d => d.moduleReference.expression)
.concat(importDeclarations.map(d => d.moduleSpecifier))
.map(d => ({
start: ts.getLineAndCharacterOfPosition(sourceFile, d.getStart()),
end: ts.getLineAndCharacterOfPosition(sourceFile, d.getEnd())
}));
// `nls.localize(...)` calls
const nlsLocalizeCallExpressions = importDeclarations
.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamespaceImport))
.map(d => d.importClause.namedBindings.name)
.concat(importEqualsDeclarations.map(d => d.name))
// find read-only references to `nls`
.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess)
// find the deepest call expressions AST nodes that contain those references
.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
.map(a => lazy(a).last())
.filter(n => !!n)
.map(n => n)
// only `localize` calls
.filter(n => n.expression.kind === ts.SyntaxKind.PropertyAccessExpression && n.expression.name.getText() === 'localize');
// `localize` named imports
const allLocalizeImportDeclarations = importDeclarations
.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamedImports))
.map(d => [].concat(d.importClause.namedBindings.elements))
.flatten();
// `localize` read-only references
const localizeReferences = allLocalizeImportDeclarations
.filter(d => d.name.getText() === 'localize')
.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess);
// custom named `localize` read-only references
const namedLocalizeReferences = allLocalizeImportDeclarations
.filter(d => d.propertyName && d.propertyName.getText() === 'localize')
.map(n => service.getReferencesAtPosition(filename, n.name.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess);
// find the deepest call expressions AST nodes that contain those references
const localizeCallExpressions = localizeReferences
.concat(namedLocalizeReferences)
.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
.map(a => lazy(a).last())
.filter(n => !!n)
.map(n => n);
// collect everything
const localizeCalls = nlsLocalizeCallExpressions
.concat(localizeCallExpressions)
.map(e => e.arguments)
.filter(a => a.length > 1)
.sort((a, b) => a[0].getStart() - b[0].getStart())
.map(a => ({
keySpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getEnd()) },
key: a[0].getText(),
valueSpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getEnd()) },
value: a[1].getText()
}));
return {
localizeCalls: localizeCalls.toArray(),
nlsExpressions: nlsExpressions.toArray()
};
}
nls_1.analyze = analyze;
class TextModel {
constructor(contents) {
const regex = /\r\n|\r|\n/g;
let index = 0;
let match;
this.lines = [];
this.lineEndings = [];
while (match = regex.exec(contents)) {
this.lines.push(contents.substring(index, match.index));
this.lineEndings.push(match[0]);
index = regex.lastIndex;
}
if (contents.length > 0) {
this.lines.push(contents.substring(index, contents.length));
this.lineEndings.push('');
}
}
get(index) {
return this.lines[index];
}
set(index, line) {
this.lines[index] = line;
}
get lineCount() {
return this.lines.length;
}
/**
* Applies patch(es) to the model.
* Multiple patches must be ordered.
* Does not support patches spanning multiple lines.
*/
apply(patch) {
const startLineNumber = patch.span.start.line;
const endLineNumber = patch.span.end.line;
const startLine = this.lines[startLineNumber] || '';
const endLine = this.lines[endLineNumber] || '';
this.lines[startLineNumber] = [
startLine.substring(0, patch.span.start.character),
patch.content,
endLine.substring(patch.span.end.character)
].join('');
for (let i = startLineNumber + 1; i <= endLineNumber; i++) {
this.lines[i] = '';
}
}
toString() {
return lazy(this.lines).zip(this.lineEndings)
.flatten().toArray().join('');
}
}
nls_1.TextModel = TextModel;
function patchJavascript(patches, contents, moduleId) {
const model = new nls.TextModel(contents);
// patch the localize calls
lazy(patches).reverse().each(p => model.apply(p));
// patch the 'vs/nls' imports
const firstLine = model.get(0);
const patchedFirstLine = firstLine.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
model.set(0, patchedFirstLine);
return model.toString();
}
nls_1.patchJavascript = patchJavascript;
function patchSourcemap(patches, rsm, smc) {
const smg = new sm.SourceMapGenerator({
file: rsm.file,
sourceRoot: rsm.sourceRoot
});
patches = patches.reverse();
let currentLine = -1;
let currentLineDiff = 0;
let source = null;
smc.eachMapping(m => {
const patch = patches[patches.length - 1];
const original = { line: m.originalLine, column: m.originalColumn };
const generated = { line: m.generatedLine, column: m.generatedColumn };
if (currentLine !== generated.line) {
currentLineDiff = 0;
}
currentLine = generated.line;
generated.column += currentLineDiff;
if (patch && m.generatedLine - 1 === patch.span.end.line && m.generatedColumn === patch.span.end.character) {
const originalLength = patch.span.end.character - patch.span.start.character;
const modifiedLength = patch.content.length;
const lengthDiff = modifiedLength - originalLength;
currentLineDiff += lengthDiff;
generated.column += lengthDiff;
patches.pop();
}
source = rsm.sourceRoot ? path.relative(rsm.sourceRoot, m.source) : m.source;
source = source.replace(/\\/g, '/');
smg.addMapping({ source, name: m.name, original, generated });
}, null, sm.SourceMapConsumer.GENERATED_ORDER);
if (source) {
smg.setSourceContent(source, smc.sourceContentFor(source));
}
return JSON.parse(smg.toString());
}
nls_1.patchSourcemap = patchSourcemap;
function patch(moduleId, typescript, javascript, sourcemap) {
const { localizeCalls, nlsExpressions } = analyze(typescript);
if (localizeCalls.length === 0) {
return { javascript, sourcemap };
}
const nlsKeys = template(localizeCalls.map(lc => lc.key));
const nls = template(localizeCalls.map(lc => lc.value));
const smc = new sm.SourceMapConsumer(sourcemap);
const positionFrom = mappedPositionFrom.bind(null, sourcemap.sources[0]);
let i = 0;
// build patches
const patches = lazy(localizeCalls)
.map(lc => ([
{ range: lc.keySpan, content: '' + (i++) },
{ range: lc.valueSpan, content: 'null' }
]))
.flatten()
.map(c => {
const start = lcFrom(smc.generatedPositionFor(positionFrom(c.range.start)));
const end = lcFrom(smc.generatedPositionFor(positionFrom(c.range.end)));
return { span: { start, end }, content: c.content };
})
.toArray();
javascript = patchJavascript(patches, javascript, moduleId);
// since imports are not within the sourcemap information,
// we must do this MacGyver style
if (nlsExpressions.length) {
javascript = javascript.replace(/^define\(.*$/m, line => {
return line.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
});
}
sourcemap = patchSourcemap(patches, sourcemap, smc);
return { javascript, sourcemap, nlsKeys, nls };
}
nls_1.patch = patch;
function patchFiles(javascriptFile, typescript) {
// hack?
const moduleId = javascriptFile.relative
.replace(/\.js$/, '')
.replace(/\\/g, '/');
const { javascript, sourcemap, nlsKeys, nls } = patch(moduleId, typescript, javascriptFile.contents.toString(), javascriptFile.sourceMap);
const result = [fileFrom(javascriptFile, javascript)];
result[0].sourceMap = sourcemap;
if (nlsKeys) {
result.push(fileFrom(javascriptFile, nlsKeys, javascriptFile.path.replace(/\.js$/, '.nls.keys.js')));
}
if (nls) {
result.push(fileFrom(javascriptFile, nls, javascriptFile.path.replace(/\.js$/, '.nls.js')));
}
return result;
}
nls_1.patchFiles = patchFiles;
})(nls || (nls = {}));
module.exports = nls;
================================================
FILE: build/lib/nls.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as lazy from 'lazy.js';
import { duplex, through } from 'event-stream';
import * as File from 'vinyl';
import * as sm from 'source-map';
import * as path from 'path';
declare class FileSourceMap extends File {
public sourceMap: sm.RawSourceMap;
}
enum CollectStepResult {
Yes,
YesAndRecurse,
No,
NoAndRecurse
}
function collect(node: ts.Node, fn: (node: ts.Node) => CollectStepResult): ts.Node[] {
const result: ts.Node[] = [];
function loop(node: ts.Node) {
const stepResult = fn(node);
if (stepResult === CollectStepResult.Yes || stepResult === CollectStepResult.YesAndRecurse) {
result.push(node);
}
if (stepResult === CollectStepResult.YesAndRecurse || stepResult === CollectStepResult.NoAndRecurse) {
ts.forEachChild(node, loop);
}
}
loop(node);
return result;
}
function clone(object: T): T {
const result = {};
for (const id in object) {
result[id] = object[id];
}
return result;
}
function template(lines: string[]): string {
let indent = '', wrap = '';
if (lines.length > 1) {
indent = '\t';
wrap = '\n';
}
return `/*---------------------------------------------------------
* Copyright (C) Microsoft Corporation. All rights reserved.
*--------------------------------------------------------*/
define([], [${ wrap + lines.map(l => indent + l).join(',\n') + wrap}]);`;
}
/**
* Returns a stream containing the patched JavaScript and source maps.
*/
function nls(): NodeJS.ReadWriteStream {
const input = through();
const output = input.pipe(through(function (f: FileSourceMap) {
if (!f.sourceMap) {
return this.emit('error', new Error(`File ${f.relative} does not have sourcemaps.`));
}
let source = f.sourceMap.sources[0];
if (!source) {
return this.emit('error', new Error(`File ${f.relative} does not have a source in the source map.`));
}
const root = f.sourceMap.sourceRoot;
if (root) {
source = path.join(root, source);
}
const typescript = f.sourceMap.sourcesContent![0];
if (!typescript) {
return this.emit('error', new Error(`File ${f.relative} does not have the original content in the source map.`));
}
nls.patchFiles(f, typescript).forEach(f => this.emit('data', f));
}));
return duplex(input, output);
}
function isImportNode(node: ts.Node): boolean {
return node.kind === ts.SyntaxKind.ImportDeclaration || node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
}
module nls {
export interface INlsStringResult {
javascript: string;
sourcemap: sm.RawSourceMap;
nls?: string;
nlsKeys?: string;
}
export interface ISpan {
start: ts.LineAndCharacter;
end: ts.LineAndCharacter;
}
export interface ILocalizeCall {
keySpan: ISpan;
key: string;
valueSpan: ISpan;
value: string;
}
export interface ILocalizeAnalysisResult {
localizeCalls: ILocalizeCall[];
nlsExpressions: ISpan[];
}
export interface IPatch {
span: ISpan;
content: string;
}
export function fileFrom(file: File, contents: string, path: string = file.path) {
return new File({
contents: Buffer.from(contents),
base: file.base,
cwd: file.cwd,
path: path
});
}
export function mappedPositionFrom(source: string, lc: ts.LineAndCharacter): sm.MappedPosition {
return { source, line: lc.line + 1, column: lc.character };
}
export function lcFrom(position: sm.Position): ts.LineAndCharacter {
return { line: position.line - 1, character: position.column };
}
export class SingleFileServiceHost implements ts.LanguageServiceHost {
private file: ts.IScriptSnapshot;
private lib: ts.IScriptSnapshot;
constructor(private options: ts.CompilerOptions, private filename: string, contents: string) {
this.file = ts.ScriptSnapshot.fromString(contents);
this.lib = ts.ScriptSnapshot.fromString('');
}
getCompilationSettings = () => this.options;
getScriptFileNames = () => [this.filename];
getScriptVersion = () => '1';
getScriptSnapshot = (name: string) => name === this.filename ? this.file : this.lib;
getCurrentDirectory = () => '';
getDefaultLibFileName = () => 'lib.d.ts';
}
function isCallExpressionWithinTextSpanCollectStep(textSpan: ts.TextSpan, node: ts.Node): CollectStepResult {
if (!ts.textSpanContainsTextSpan({ start: node.pos, length: node.end - node.pos }, textSpan)) {
return CollectStepResult.No;
}
return node.kind === ts.SyntaxKind.CallExpression ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse;
}
export function analyze(contents: string, options: ts.CompilerOptions = {}): ILocalizeAnalysisResult {
const filename = 'file.ts';
const serviceHost = new SingleFileServiceHost(Object.assign(clone(options), { noResolve: true }), filename, contents);
const service = ts.createLanguageService(serviceHost);
const sourceFile = ts.createSourceFile(filename, contents, ts.ScriptTarget.ES5, true);
// all imports
const imports = lazy(collect(sourceFile, n => isImportNode(n) ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse));
// import nls = require('vs/nls');
const importEqualsDeclarations = imports
.filter(n => n.kind === ts.SyntaxKind.ImportEqualsDeclaration)
.map(n => n)
.filter(d => d.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference)
.filter(d => (d.moduleReference).expression.getText() === '\'vs/nls\'');
// import ... from 'vs/nls';
const importDeclarations = imports
.filter(n => n.kind === ts.SyntaxKind.ImportDeclaration)
.map(n => n)
.filter(d => d.moduleSpecifier.kind === ts.SyntaxKind.StringLiteral)
.filter(d => d.moduleSpecifier.getText() === '\'vs/nls\'')
.filter(d => !!d.importClause && !!d.importClause.namedBindings);
const nlsExpressions = importEqualsDeclarations
.map(d => (d.moduleReference).expression)
.concat(importDeclarations.map(d => d.moduleSpecifier))
.map(d => ({
start: ts.getLineAndCharacterOfPosition(sourceFile, d.getStart()),
end: ts.getLineAndCharacterOfPosition(sourceFile, d.getEnd())
}));
// `nls.localize(...)` calls
const nlsLocalizeCallExpressions = importDeclarations
.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamespaceImport))
.map(d => (d.importClause!.namedBindings).name)
.concat(importEqualsDeclarations.map(d => d.name))
// find read-only references to `nls`
.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess)
// find the deepest call expressions AST nodes that contain those references
.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
.map(a => lazy(a).last())
.filter(n => !!n)
.map(n => n)
// only `localize` calls
.filter(n => n.expression.kind === ts.SyntaxKind.PropertyAccessExpression && (n.expression).name.getText() === 'localize');
// `localize` named imports
const allLocalizeImportDeclarations = importDeclarations
.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamedImports))
.map(d => ([] as any[]).concat((d.importClause!.namedBindings!).elements))
.flatten();
// `localize` read-only references
const localizeReferences = allLocalizeImportDeclarations
.filter(d => d.name.getText() === 'localize')
.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess);
// custom named `localize` read-only references
const namedLocalizeReferences = allLocalizeImportDeclarations
.filter(d => d.propertyName && d.propertyName.getText() === 'localize')
.map(n => service.getReferencesAtPosition(filename, n.name.pos + 1))
.flatten()
.filter(r => !r.isWriteAccess);
// find the deepest call expressions AST nodes that contain those references
const localizeCallExpressions = localizeReferences
.concat(namedLocalizeReferences)
.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
.map(a => lazy(a).last())
.filter(n => !!n)
.map(n => n);
// collect everything
const localizeCalls = nlsLocalizeCallExpressions
.concat(localizeCallExpressions)
.map(e => e.arguments)
.filter(a => a.length > 1)
.sort((a, b) => a[0].getStart() - b[0].getStart())
.map(a => ({
keySpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getEnd()) },
key: a[0].getText(),
valueSpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getEnd()) },
value: a[1].getText()
}));
return {
localizeCalls: localizeCalls.toArray(),
nlsExpressions: nlsExpressions.toArray()
};
}
export class TextModel {
private lines: string[];
private lineEndings: string[];
constructor(contents: string) {
const regex = /\r\n|\r|\n/g;
let index = 0;
let match: RegExpExecArray | null;
this.lines = [];
this.lineEndings = [];
while (match = regex.exec(contents)) {
this.lines.push(contents.substring(index, match.index));
this.lineEndings.push(match[0]);
index = regex.lastIndex;
}
if (contents.length > 0) {
this.lines.push(contents.substring(index, contents.length));
this.lineEndings.push('');
}
}
public get(index: number): string {
return this.lines[index];
}
public set(index: number, line: string): void {
this.lines[index] = line;
}
public get lineCount(): number {
return this.lines.length;
}
/**
* Applies patch(es) to the model.
* Multiple patches must be ordered.
* Does not support patches spanning multiple lines.
*/
public apply(patch: IPatch): void {
const startLineNumber = patch.span.start.line;
const endLineNumber = patch.span.end.line;
const startLine = this.lines[startLineNumber] || '';
const endLine = this.lines[endLineNumber] || '';
this.lines[startLineNumber] = [
startLine.substring(0, patch.span.start.character),
patch.content,
endLine.substring(patch.span.end.character)
].join('');
for (let i = startLineNumber + 1; i <= endLineNumber; i++) {
this.lines[i] = '';
}
}
public toString(): string {
return lazy(this.lines).zip(this.lineEndings)
.flatten().toArray().join('');
}
}
export function patchJavascript(patches: IPatch[], contents: string, moduleId: string): string {
const model = new nls.TextModel(contents);
// patch the localize calls
lazy(patches).reverse().each(p => model.apply(p));
// patch the 'vs/nls' imports
const firstLine = model.get(0);
const patchedFirstLine = firstLine.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
model.set(0, patchedFirstLine);
return model.toString();
}
export function patchSourcemap(patches: IPatch[], rsm: sm.RawSourceMap, smc: sm.SourceMapConsumer): sm.RawSourceMap {
const smg = new sm.SourceMapGenerator({
file: rsm.file,
sourceRoot: rsm.sourceRoot
});
patches = patches.reverse();
let currentLine = -1;
let currentLineDiff = 0;
let source: string | null = null;
smc.eachMapping(m => {
const patch = patches[patches.length - 1];
const original = { line: m.originalLine, column: m.originalColumn };
const generated = { line: m.generatedLine, column: m.generatedColumn };
if (currentLine !== generated.line) {
currentLineDiff = 0;
}
currentLine = generated.line;
generated.column += currentLineDiff;
if (patch && m.generatedLine - 1 === patch.span.end.line && m.generatedColumn === patch.span.end.character) {
const originalLength = patch.span.end.character - patch.span.start.character;
const modifiedLength = patch.content.length;
const lengthDiff = modifiedLength - originalLength;
currentLineDiff += lengthDiff;
generated.column += lengthDiff;
patches.pop();
}
source = rsm.sourceRoot ? path.relative(rsm.sourceRoot, m.source) : m.source;
source = source.replace(/\\/g, '/');
smg.addMapping({ source, name: m.name, original, generated });
}, null, sm.SourceMapConsumer.GENERATED_ORDER);
if (source) {
smg.setSourceContent(source, smc.sourceContentFor(source));
}
return JSON.parse(smg.toString());
}
export function patch(moduleId: string, typescript: string, javascript: string, sourcemap: sm.RawSourceMap): INlsStringResult {
const { localizeCalls, nlsExpressions } = analyze(typescript);
if (localizeCalls.length === 0) {
return { javascript, sourcemap };
}
const nlsKeys = template(localizeCalls.map(lc => lc.key));
const nls = template(localizeCalls.map(lc => lc.value));
const smc = new sm.SourceMapConsumer(sourcemap);
const positionFrom = mappedPositionFrom.bind(null, sourcemap.sources[0]);
let i = 0;
// build patches
const patches = lazy(localizeCalls)
.map(lc => ([
{ range: lc.keySpan, content: '' + (i++) },
{ range: lc.valueSpan, content: 'null' }
]))
.flatten()
.map(c => {
const start = lcFrom(smc.generatedPositionFor(positionFrom(c.range.start)));
const end = lcFrom(smc.generatedPositionFor(positionFrom(c.range.end)));
return { span: { start, end }, content: c.content };
})
.toArray();
javascript = patchJavascript(patches, javascript, moduleId);
// since imports are not within the sourcemap information,
// we must do this MacGyver style
if (nlsExpressions.length) {
javascript = javascript.replace(/^define\(.*$/m, line => {
return line.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
});
}
sourcemap = patchSourcemap(patches, sourcemap, smc);
return { javascript, sourcemap, nlsKeys, nls };
}
export function patchFiles(javascriptFile: File, typescript: string): File[] {
// hack?
const moduleId = javascriptFile.relative
.replace(/\.js$/, '')
.replace(/\\/g, '/');
const { javascript, sourcemap, nlsKeys, nls } = patch(
moduleId,
typescript,
javascriptFile.contents.toString(),
(javascriptFile).sourceMap
);
const result: File[] = [fileFrom(javascriptFile, javascript)];
(result[0]).sourceMap = sourcemap;
if (nlsKeys) {
result.push(fileFrom(javascriptFile, nlsKeys, javascriptFile.path.replace(/\.js$/, '.nls.keys.js')));
}
if (nls) {
result.push(fileFrom(javascriptFile, nls, javascriptFile.path.replace(/\.js$/, '.nls.js')));
}
return result;
}
}
export = nls;
================================================
FILE: build/lib/node.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fs = require("fs");
const root = path.dirname(path.dirname(__dirname));
const yarnrcPath = path.join(root, 'remote', '.yarnrc');
const yarnrc = fs.readFileSync(yarnrcPath, 'utf8');
const version = /^target\s+"([^"]+)"$/m.exec(yarnrc)[1];
const node = process.platform === 'win32' ? 'node.exe' : 'node';
const nodePath = path.join(root, '.build', 'node', `v${version}`, `${process.platform}-${process.arch}`, node);
console.log(nodePath);
================================================
FILE: build/lib/node.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as path from 'path';
import * as fs from 'fs';
const root = path.dirname(path.dirname(__dirname));
const yarnrcPath = path.join(root, 'remote', '.yarnrc');
const yarnrc = fs.readFileSync(yarnrcPath, 'utf8');
const version = /^target\s+"([^"]+)"$/m.exec(yarnrc)![1];
const node = process.platform === 'win32' ? 'node.exe' : 'node';
const nodePath = path.join(root, '.build', 'node', `v${version}`, `${process.platform}-${process.arch}`, node);
console.log(nodePath);
================================================
FILE: build/lib/optimize.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const es = require("event-stream");
const fs = require("fs");
const gulp = require("gulp");
const concat = require("gulp-concat");
const minifyCSS = require("gulp-cssnano");
const filter = require("gulp-filter");
const flatmap = require("gulp-flatmap");
const sourcemaps = require("gulp-sourcemaps");
const uglify = require("gulp-uglify");
const composer = require("gulp-uglify/composer");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const path = require("path");
const pump = require("pump");
const terser = require("terser");
const VinylFile = require("vinyl");
const bundle = require("./bundle");
const i18n_1 = require("./i18n");
const stats_1 = require("./stats");
const util = require("./util");
const REPO_ROOT_PATH = path.join(__dirname, '../..');
function log(prefix, message) {
fancyLog(ansiColors.cyan('[' + prefix + ']'), message);
}
function loaderConfig(emptyPaths) {
const result = {
paths: {
'vs': 'out-build/vs',
'vscode': 'empty:'
},
nodeModules: emptyPaths || []
};
result['vs/css'] = { inlineResources: true };
return result;
}
exports.loaderConfig = loaderConfig;
const IS_OUR_COPYRIGHT_REGEXP = /Copyright \(C\) Microsoft Corporation/i;
function loader(src, bundledFileHeader, bundleLoader) {
let sources = [
`${src}/vs/loader.js`
];
if (bundleLoader) {
sources = sources.concat([
`${src}/vs/css.js`,
`${src}/vs/nls.js`
]);
}
let isFirst = true;
return (gulp
.src(sources, { base: `${src}` })
.pipe(es.through(function (data) {
if (isFirst) {
isFirst = false;
this.emit('data', new VinylFile({
path: 'fake',
base: '',
contents: Buffer.from(bundledFileHeader)
}));
this.emit('data', data);
}
else {
this.emit('data', data);
}
}))
.pipe(util.loadSourcemaps())
.pipe(concat('vs/loader.js'))
.pipe(es.mapSync(function (f) {
f.sourceMap.sourceRoot = util.toFileUri(path.join(REPO_ROOT_PATH, 'src'));
return f;
})));
}
function toConcatStream(src, bundledFileHeader, sources, dest) {
const useSourcemaps = /\.js$/.test(dest) && !/\.nls\.js$/.test(dest);
// If a bundle ends up including in any of the sources our copyright, then
// insert a fake source at the beginning of each bundle with our copyright
let containsOurCopyright = false;
for (let i = 0, len = sources.length; i < len; i++) {
const fileContents = sources[i].contents;
if (IS_OUR_COPYRIGHT_REGEXP.test(fileContents)) {
containsOurCopyright = true;
break;
}
}
if (containsOurCopyright) {
sources.unshift({
path: null,
contents: bundledFileHeader
});
}
const treatedSources = sources.map(function (source) {
const root = source.path ? REPO_ROOT_PATH.replace(/\\/g, '/') : '';
const base = source.path ? root + `/${src}` : '';
return new VinylFile({
path: source.path ? root + '/' + source.path.replace(/\\/g, '/') : 'fake',
base: base,
contents: Buffer.from(source.contents)
});
});
return es.readArray(treatedSources)
.pipe(useSourcemaps ? util.loadSourcemaps() : es.through())
.pipe(concat(dest))
.pipe(stats_1.createStatsStream(dest));
}
function toBundleStream(src, bundledFileHeader, bundles) {
return es.merge(bundles.map(function (bundle) {
return toConcatStream(src, bundledFileHeader, bundle.sources, bundle.dest);
}));
}
const DEFAULT_FILE_HEADER = [
'/*!--------------------------------------------------------',
' * Copyright (C) Microsoft Corporation. All rights reserved.',
' *--------------------------------------------------------*/'
].join('\n');
function optimizeTask(opts) {
const src = opts.src;
const entryPoints = opts.entryPoints;
const resources = opts.resources;
const loaderConfig = opts.loaderConfig;
const bundledFileHeader = opts.header || DEFAULT_FILE_HEADER;
const bundleLoader = (typeof opts.bundleLoader === 'undefined' ? true : opts.bundleLoader);
const out = opts.out;
return function () {
const bundlesStream = es.through(); // this stream will contain the bundled files
const resourcesStream = es.through(); // this stream will contain the resources
const bundleInfoStream = es.through(); // this stream will contain bundleInfo.json
bundle.bundle(entryPoints, loaderConfig, function (err, result) {
if (err || !result) {
return bundlesStream.emit('error', JSON.stringify(err));
}
if (opts.inlineAmdImages) {
try {
result = inlineAmdImages(src, result);
}
catch (err) {
return bundlesStream.emit('error', JSON.stringify(err));
}
}
toBundleStream(src, bundledFileHeader, result.files).pipe(bundlesStream);
// Remove css inlined resources
const filteredResources = resources.slice();
result.cssInlinedResources.forEach(function (resource) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log('optimizer', 'excluding inlined: ' + resource);
}
filteredResources.push('!' + resource);
});
gulp.src(filteredResources, { base: `${src}`, allowEmpty: true }).pipe(resourcesStream);
const bundleInfoArray = [];
if (opts.bundleInfo) {
bundleInfoArray.push(new VinylFile({
path: 'bundleInfo.json',
base: '.',
contents: Buffer.from(JSON.stringify(result.bundleData, null, '\t'))
}));
}
es.readArray(bundleInfoArray).pipe(bundleInfoStream);
});
const result = es.merge(loader(src, bundledFileHeader, bundleLoader), bundlesStream, resourcesStream, bundleInfoStream);
return result
.pipe(sourcemaps.write('./', {
sourceRoot: undefined,
addComment: true,
includeContent: true
}))
.pipe(opts.languages && opts.languages.length ? i18n_1.processNlsFiles({
fileHeader: bundledFileHeader,
languages: opts.languages
}) : es.through())
.pipe(gulp.dest(out));
};
}
exports.optimizeTask = optimizeTask;
function inlineAmdImages(src, result) {
for (const outputFile of result.files) {
for (const sourceFile of outputFile.sources) {
if (sourceFile.path && /\.js$/.test(sourceFile.path)) {
sourceFile.contents = sourceFile.contents.replace(/\([^.]+\.registerAndGetAmdImageURL\(([^)]+)\)\)/g, (_, m0) => {
let imagePath = m0;
// remove `` or ''
if ((imagePath.charAt(0) === '`' && imagePath.charAt(imagePath.length - 1) === '`')
|| (imagePath.charAt(0) === '\'' && imagePath.charAt(imagePath.length - 1) === '\'')) {
imagePath = imagePath.substr(1, imagePath.length - 2);
}
if (!/\.(png|svg)$/.test(imagePath)) {
console.log(`original: ${_}`);
return _;
}
const repoLocation = path.join(src, imagePath);
const absoluteLocation = path.join(REPO_ROOT_PATH, repoLocation);
if (!fs.existsSync(absoluteLocation)) {
const message = `Invalid amd image url in file ${sourceFile.path}: ${imagePath}`;
console.log(message);
throw new Error(message);
}
const fileContents = fs.readFileSync(absoluteLocation);
const mime = /\.svg$/.test(imagePath) ? 'image/svg+xml' : 'image/png';
// Mark the file as inlined so we don't ship it by itself
result.cssInlinedResources.push(repoLocation);
return `("data:${mime};base64,${fileContents.toString('base64')}")`;
});
}
}
}
return result;
}
/**
* Wrap around uglify and allow the preserveComments function
* to have a file "context" to include our copyright only once per file.
*/
function uglifyWithCopyrights() {
const preserveComments = (f) => {
return (_node, comment) => {
const text = comment.value;
const type = comment.type;
if (/@minifier_do_not_preserve/.test(text)) {
return false;
}
const isOurCopyright = IS_OUR_COPYRIGHT_REGEXP.test(text);
if (isOurCopyright) {
if (f.__hasOurCopyright) {
return false;
}
f.__hasOurCopyright = true;
return true;
}
if ('comment2' === type) {
// check for /*!. Note that text doesn't contain leading /*
return (text.length > 0 && text[0] === '!') || /@preserve|license|@cc_on|copyright/i.test(text);
}
else if ('comment1' === type) {
return /license|copyright/i.test(text);
}
return false;
};
};
const minify = composer(terser);
const input = es.through();
const output = input
.pipe(flatmap((stream, f) => {
return stream.pipe(minify({
output: {
comments: preserveComments(f),
max_line_len: 1024
}
}));
}));
return es.duplex(input, output);
}
function minifyTask(src, sourceMapBaseUrl) {
const sourceMappingURL = sourceMapBaseUrl ? ((f) => `${sourceMapBaseUrl}/${f.relative}.map`) : undefined;
return cb => {
const jsFilter = filter('**/*.js', { restore: true });
const cssFilter = filter('**/*.css', { restore: true });
pump(gulp.src([src + '/**', '!' + src + '/**/*.map']), jsFilter, sourcemaps.init({ loadMaps: true }), uglifyWithCopyrights(), jsFilter.restore, cssFilter, minifyCSS({ reduceIdents: false }), cssFilter.restore, sourcemaps.mapSources((sourcePath) => {
if (sourcePath === 'bootstrap-fork.js') {
return 'bootstrap-fork.orig.js';
}
return sourcePath;
}), sourcemaps.write('./', {
sourceMappingURL,
sourceRoot: null,
includeContent: true,
addComment: true
}), gulp.dest(src + '-min'), (err) => {
if (err instanceof uglify.GulpUglifyError) {
console.error(`Uglify error in '${err.cause && err.cause.filename}'`);
}
cb(err);
});
};
}
exports.minifyTask = minifyTask;
================================================
FILE: build/lib/optimize.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as es from 'event-stream';
import * as fs from 'fs';
import * as gulp from 'gulp';
import * as concat from 'gulp-concat';
import * as minifyCSS from 'gulp-cssnano';
import * as filter from 'gulp-filter';
import * as flatmap from 'gulp-flatmap';
import * as sourcemaps from 'gulp-sourcemaps';
import * as uglify from 'gulp-uglify';
import * as composer from 'gulp-uglify/composer';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
import * as path from 'path';
import * as pump from 'pump';
import * as sm from 'source-map';
import * as terser from 'terser';
import * as VinylFile from 'vinyl';
import * as bundle from './bundle';
import { Language, processNlsFiles } from './i18n';
import { createStatsStream } from './stats';
import * as util from './util';
const REPO_ROOT_PATH = path.join(__dirname, '../..');
function log(prefix: string, message: string): void {
fancyLog(ansiColors.cyan('[' + prefix + ']'), message);
}
export function loaderConfig(emptyPaths?: string[]) {
const result: any = {
paths: {
'vs': 'out-build/vs',
'vscode': 'empty:'
},
nodeModules: emptyPaths || []
};
result['vs/css'] = { inlineResources: true };
return result;
}
const IS_OUR_COPYRIGHT_REGEXP = /Copyright \(C\) Microsoft Corporation/i;
declare class FileSourceMap extends VinylFile {
public sourceMap: sm.RawSourceMap;
}
function loader(src: string, bundledFileHeader: string, bundleLoader: boolean): NodeJS.ReadWriteStream {
let sources = [
`${src}/vs/loader.js`
];
if (bundleLoader) {
sources = sources.concat([
`${src}/vs/css.js`,
`${src}/vs/nls.js`
]);
}
let isFirst = true;
return (
gulp
.src(sources, { base: `${src}` })
.pipe(es.through(function (data) {
if (isFirst) {
isFirst = false;
this.emit('data', new VinylFile({
path: 'fake',
base: '',
contents: Buffer.from(bundledFileHeader)
}));
this.emit('data', data);
} else {
this.emit('data', data);
}
}))
.pipe(util.loadSourcemaps())
.pipe(concat('vs/loader.js'))
.pipe(es.mapSync(function (f) {
f.sourceMap.sourceRoot = util.toFileUri(path.join(REPO_ROOT_PATH, 'src'));
return f;
}))
);
}
function toConcatStream(src: string, bundledFileHeader: string, sources: bundle.IFile[], dest: string): NodeJS.ReadWriteStream {
const useSourcemaps = /\.js$/.test(dest) && !/\.nls\.js$/.test(dest);
// If a bundle ends up including in any of the sources our copyright, then
// insert a fake source at the beginning of each bundle with our copyright
let containsOurCopyright = false;
for (let i = 0, len = sources.length; i < len; i++) {
const fileContents = sources[i].contents;
if (IS_OUR_COPYRIGHT_REGEXP.test(fileContents)) {
containsOurCopyright = true;
break;
}
}
if (containsOurCopyright) {
sources.unshift({
path: null,
contents: bundledFileHeader
});
}
const treatedSources = sources.map(function (source) {
const root = source.path ? REPO_ROOT_PATH.replace(/\\/g, '/') : '';
const base = source.path ? root + `/${src}` : '';
return new VinylFile({
path: source.path ? root + '/' + source.path.replace(/\\/g, '/') : 'fake',
base: base,
contents: Buffer.from(source.contents)
});
});
return es.readArray(treatedSources)
.pipe(useSourcemaps ? util.loadSourcemaps() : es.through())
.pipe(concat(dest))
.pipe(createStatsStream(dest));
}
function toBundleStream(src: string, bundledFileHeader: string, bundles: bundle.IConcatFile[]): NodeJS.ReadWriteStream {
return es.merge(bundles.map(function (bundle) {
return toConcatStream(src, bundledFileHeader, bundle.sources, bundle.dest);
}));
}
export interface IOptimizeTaskOpts {
/**
* The folder to read files from.
*/
src: string;
/**
* (for AMD files, will get bundled and get Copyright treatment)
*/
entryPoints: bundle.IEntryPoint[];
/**
* (svg, etc.)
*/
resources: string[];
loaderConfig: any;
/**
* (true by default - append css and nls to loader)
*/
bundleLoader?: boolean;
/**
* (basically the Copyright treatment)
*/
header?: string;
/**
* (emit bundleInfo.json file)
*/
bundleInfo: boolean;
/**
* replace calls to `registerAndGetAmdImageURL` with data uris
*/
inlineAmdImages: boolean;
/**
* (out folder name)
*/
out: string;
/**
* (out folder name)
*/
languages?: Language[];
}
const DEFAULT_FILE_HEADER = [
'/*!--------------------------------------------------------',
' * Copyright (C) Microsoft Corporation. All rights reserved.',
' *--------------------------------------------------------*/'
].join('\n');
export function optimizeTask(opts: IOptimizeTaskOpts): () => NodeJS.ReadWriteStream {
const src = opts.src;
const entryPoints = opts.entryPoints;
const resources = opts.resources;
const loaderConfig = opts.loaderConfig;
const bundledFileHeader = opts.header || DEFAULT_FILE_HEADER;
const bundleLoader = (typeof opts.bundleLoader === 'undefined' ? true : opts.bundleLoader);
const out = opts.out;
return function () {
const bundlesStream = es.through(); // this stream will contain the bundled files
const resourcesStream = es.through(); // this stream will contain the resources
const bundleInfoStream = es.through(); // this stream will contain bundleInfo.json
bundle.bundle(entryPoints, loaderConfig, function (err, result) {
if (err || !result) { return bundlesStream.emit('error', JSON.stringify(err)); }
if (opts.inlineAmdImages) {
try {
result = inlineAmdImages(src, result);
} catch (err) {
return bundlesStream.emit('error', JSON.stringify(err));
}
}
toBundleStream(src, bundledFileHeader, result.files).pipe(bundlesStream);
// Remove css inlined resources
const filteredResources = resources.slice();
result.cssInlinedResources.forEach(function (resource) {
if (process.env['VSCODE_BUILD_VERBOSE']) {
log('optimizer', 'excluding inlined: ' + resource);
}
filteredResources.push('!' + resource);
});
gulp.src(filteredResources, { base: `${src}`, allowEmpty: true }).pipe(resourcesStream);
const bundleInfoArray: VinylFile[] = [];
if (opts.bundleInfo) {
bundleInfoArray.push(new VinylFile({
path: 'bundleInfo.json',
base: '.',
contents: Buffer.from(JSON.stringify(result.bundleData, null, '\t'))
}));
}
es.readArray(bundleInfoArray).pipe(bundleInfoStream);
});
const result = es.merge(
loader(src, bundledFileHeader, bundleLoader),
bundlesStream,
resourcesStream,
bundleInfoStream
);
return result
.pipe(sourcemaps.write('./', {
sourceRoot: undefined,
addComment: true,
includeContent: true
}))
.pipe(opts.languages && opts.languages.length ? processNlsFiles({
fileHeader: bundledFileHeader,
languages: opts.languages
}) : es.through())
.pipe(gulp.dest(out));
};
}
function inlineAmdImages(src: string, result: bundle.IBundleResult): bundle.IBundleResult {
for (const outputFile of result.files) {
for (const sourceFile of outputFile.sources) {
if (sourceFile.path && /\.js$/.test(sourceFile.path)) {
sourceFile.contents = sourceFile.contents.replace(/\([^.]+\.registerAndGetAmdImageURL\(([^)]+)\)\)/g, (_, m0) => {
let imagePath = m0;
// remove `` or ''
if ((imagePath.charAt(0) === '`' && imagePath.charAt(imagePath.length - 1) === '`')
|| (imagePath.charAt(0) === '\'' && imagePath.charAt(imagePath.length - 1) === '\'')) {
imagePath = imagePath.substr(1, imagePath.length - 2);
}
if (!/\.(png|svg)$/.test(imagePath)) {
console.log(`original: ${_}`);
return _;
}
const repoLocation = path.join(src, imagePath);
const absoluteLocation = path.join(REPO_ROOT_PATH, repoLocation);
if (!fs.existsSync(absoluteLocation)) {
const message = `Invalid amd image url in file ${sourceFile.path}: ${imagePath}`;
console.log(message);
throw new Error(message);
}
const fileContents = fs.readFileSync(absoluteLocation);
const mime = /\.svg$/.test(imagePath) ? 'image/svg+xml' : 'image/png';
// Mark the file as inlined so we don't ship it by itself
result.cssInlinedResources.push(repoLocation);
return `("data:${mime};base64,${fileContents.toString('base64')}")`;
});
}
}
}
return result;
}
declare class FileWithCopyright extends VinylFile {
public __hasOurCopyright: boolean;
}
/**
* Wrap around uglify and allow the preserveComments function
* to have a file "context" to include our copyright only once per file.
*/
function uglifyWithCopyrights(): NodeJS.ReadWriteStream {
const preserveComments = (f: FileWithCopyright) => {
return (_node: any, comment: { value: string; type: string; }) => {
const text = comment.value;
const type = comment.type;
if (/@minifier_do_not_preserve/.test(text)) {
return false;
}
const isOurCopyright = IS_OUR_COPYRIGHT_REGEXP.test(text);
if (isOurCopyright) {
if (f.__hasOurCopyright) {
return false;
}
f.__hasOurCopyright = true;
return true;
}
if ('comment2' === type) {
// check for /*!. Note that text doesn't contain leading /*
return (text.length > 0 && text[0] === '!') || /@preserve|license|@cc_on|copyright/i.test(text);
} else if ('comment1' === type) {
return /license|copyright/i.test(text);
}
return false;
};
};
const minify = (composer as any)(terser);
const input = es.through();
const output = input
.pipe(flatmap((stream, f) => {
return stream.pipe(minify({
output: {
comments: preserveComments(f),
max_line_len: 1024
}
}));
}));
return es.duplex(input, output);
}
export function minifyTask(src: string, sourceMapBaseUrl?: string): (cb: any) => void {
const sourceMappingURL = sourceMapBaseUrl ? ((f: any) => `${sourceMapBaseUrl}/${f.relative}.map`) : undefined;
return cb => {
const jsFilter = filter('**/*.js', { restore: true });
const cssFilter = filter('**/*.css', { restore: true });
pump(
gulp.src([src + '/**', '!' + src + '/**/*.map']),
jsFilter,
sourcemaps.init({ loadMaps: true }),
uglifyWithCopyrights(),
jsFilter.restore,
cssFilter,
minifyCSS({ reduceIdents: false }),
cssFilter.restore,
(sourcemaps).mapSources((sourcePath: string) => {
if (sourcePath === 'bootstrap-fork.js') {
return 'bootstrap-fork.orig.js';
}
return sourcePath;
}),
sourcemaps.write('./', {
sourceMappingURL,
sourceRoot: null,
includeContent: true,
addComment: true
} as any),
gulp.dest(src + '-min')
, (err: any) => {
if (err instanceof (uglify as any).GulpUglifyError) {
console.error(`Uglify error in '${err.cause && err.cause.filename}'`);
}
cb(err);
});
};
}
================================================
FILE: build/lib/reporter.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const es = require("event-stream");
const _ = require("underscore");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const fs = require("fs");
const path = require("path");
const allErrors = [];
let startTime = null;
let count = 0;
function onStart() {
if (count++ > 0) {
return;
}
startTime = new Date().getTime();
fancyLog(`Starting ${ansiColors.green('compilation')}...`);
}
function onEnd() {
if (--count > 0) {
return;
}
log();
}
const buildLogPath = path.join(path.dirname(path.dirname(__dirname)), '.build', 'log');
try {
fs.mkdirSync(path.dirname(buildLogPath));
}
catch (err) {
// ignore
}
function log() {
const errors = _.flatten(allErrors);
const seen = new Set();
errors.map(err => {
if (!seen.has(err)) {
seen.add(err);
fancyLog(`${ansiColors.red('Error')}: ${err}`);
}
});
const regex = /^([^(]+)\((\d+),(\d+)\): (.*)$/;
const messages = errors
.map(err => regex.exec(err))
.filter(match => !!match)
.map(x => x)
.map(([, path, line, column, message]) => ({ path, line: parseInt(line), column: parseInt(column), message }));
try {
fs.writeFileSync(buildLogPath, JSON.stringify(messages));
}
catch (err) {
//noop
}
fancyLog(`Finished ${ansiColors.green('compilation')} with ${errors.length} errors after ${ansiColors.magenta((new Date().getTime() - startTime) + ' ms')}`);
}
function createReporter() {
const errors = [];
allErrors.push(errors);
const result = (err) => errors.push(err);
result.hasErrors = () => errors.length > 0;
result.end = (emitError) => {
errors.length = 0;
onStart();
return es.through(undefined, function () {
onEnd();
if (emitError && errors.length > 0) {
if (!errors.__logged__) {
log();
}
errors.__logged__ = true;
const err = new Error(`Found ${errors.length} errors`);
err.__reporter__ = true;
this.emit('error', err);
}
else {
this.emit('end');
}
});
};
return result;
}
exports.createReporter = createReporter;
================================================
FILE: build/lib/reporter.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as es from 'event-stream';
import * as _ from 'underscore';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
import * as fs from 'fs';
import * as path from 'path';
const allErrors: string[][] = [];
let startTime: number | null = null;
let count = 0;
function onStart(): void {
if (count++ > 0) {
return;
}
startTime = new Date().getTime();
fancyLog(`Starting ${ansiColors.green('compilation')}...`);
}
function onEnd(): void {
if (--count > 0) {
return;
}
log();
}
const buildLogPath = path.join(path.dirname(path.dirname(__dirname)), '.build', 'log');
try {
fs.mkdirSync(path.dirname(buildLogPath));
} catch (err) {
// ignore
}
function log(): void {
const errors = _.flatten(allErrors);
const seen = new Set();
errors.map(err => {
if (!seen.has(err)) {
seen.add(err);
fancyLog(`${ansiColors.red('Error')}: ${err}`);
}
});
const regex = /^([^(]+)\((\d+),(\d+)\): (.*)$/;
const messages = errors
.map(err => regex.exec(err))
.filter(match => !!match)
.map(x => x as string[])
.map(([, path, line, column, message]) => ({ path, line: parseInt(line), column: parseInt(column), message }));
try {
fs.writeFileSync(buildLogPath, JSON.stringify(messages));
} catch (err) {
//noop
}
fancyLog(`Finished ${ansiColors.green('compilation')} with ${errors.length} errors after ${ansiColors.magenta((new Date().getTime() - startTime!) + ' ms')}`);
}
export interface IReporter {
(err: string): void;
hasErrors(): boolean;
end(emitError: boolean): NodeJS.ReadWriteStream;
}
export function createReporter(): IReporter {
const errors: string[] = [];
allErrors.push(errors);
const result = (err: string) => errors.push(err);
result.hasErrors = () => errors.length > 0;
result.end = (emitError: boolean): NodeJS.ReadWriteStream => {
errors.length = 0;
onStart();
return es.through(undefined, function () {
onEnd();
if (emitError && errors.length > 0) {
if (!(errors as any).__logged__) {
log();
}
(errors as any).__logged__ = true;
const err = new Error(`Found ${errors.length} errors`);
(err as any).__reporter__ = true;
this.emit('error', err);
} else {
this.emit('end');
}
});
};
return result;
}
================================================
FILE: build/lib/snapshotLoader.js
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
var snaps;
(function (snaps) {
const fs = require('fs');
const path = require('path');
const os = require('os');
const cp = require('child_process');
const mksnapshot = path.join(__dirname, `../../node_modules/.bin/${process.platform === 'win32' ? 'mksnapshot.cmd' : 'mksnapshot'}`);
const product = require('../../product.json');
const arch = (process.argv.join('').match(/--arch=(.*)/) || [])[1];
//
let loaderFilepath;
let startupBlobFilepath;
switch (process.platform) {
case 'darwin':
loaderFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Resources/app/out/vs/loader.js`;
startupBlobFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Frameworks/Electron Framework.framework/Resources/snapshot_blob.bin`;
break;
case 'win32':
case 'linux':
loaderFilepath = `VSCode-${process.platform}-${arch}/resources/app/out/vs/loader.js`;
startupBlobFilepath = `VSCode-${process.platform}-${arch}/snapshot_blob.bin`;
break;
default:
throw new Error('Unknown platform');
}
loaderFilepath = path.join(__dirname, '../../../', loaderFilepath);
startupBlobFilepath = path.join(__dirname, '../../../', startupBlobFilepath);
snapshotLoader(loaderFilepath, startupBlobFilepath);
function snapshotLoader(loaderFilepath, startupBlobFilepath) {
const inputFile = fs.readFileSync(loaderFilepath);
const wrappedInputFile = `
var Monaco_Loader_Init;
(function() {
var doNotInitLoader = true;
${inputFile.toString()};
Monaco_Loader_Init = function() {
AMDLoader.init();
CSSLoaderPlugin.init();
NLSLoaderPlugin.init();
return { define, require };
}
})();
`;
const wrappedInputFilepath = path.join(os.tmpdir(), 'wrapped-loader.js');
console.log(wrappedInputFilepath);
fs.writeFileSync(wrappedInputFilepath, wrappedInputFile);
cp.execFileSync(mksnapshot, [wrappedInputFilepath, `--startup_blob`, startupBlobFilepath]);
}
})(snaps || (snaps = {}));
================================================
FILE: build/lib/snapshotLoader.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
namespace snaps {
const fs = require('fs');
const path = require('path');
const os = require('os');
const cp = require('child_process');
const mksnapshot = path.join(__dirname, `../../node_modules/.bin/${process.platform === 'win32' ? 'mksnapshot.cmd' : 'mksnapshot'}`);
const product = require('../../product.json');
const arch = (process.argv.join('').match(/--arch=(.*)/) || [])[1];
//
let loaderFilepath: string;
let startupBlobFilepath: string;
switch (process.platform) {
case 'darwin':
loaderFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Resources/app/out/vs/loader.js`;
startupBlobFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Frameworks/Electron Framework.framework/Resources/snapshot_blob.bin`;
break;
case 'win32':
case 'linux':
loaderFilepath = `VSCode-${process.platform}-${arch}/resources/app/out/vs/loader.js`;
startupBlobFilepath = `VSCode-${process.platform}-${arch}/snapshot_blob.bin`;
break;
default:
throw new Error('Unknown platform');
}
loaderFilepath = path.join(__dirname, '../../../', loaderFilepath);
startupBlobFilepath = path.join(__dirname, '../../../', startupBlobFilepath);
snapshotLoader(loaderFilepath, startupBlobFilepath);
function snapshotLoader(loaderFilepath: string, startupBlobFilepath: string): void {
const inputFile = fs.readFileSync(loaderFilepath);
const wrappedInputFile = `
var Monaco_Loader_Init;
(function() {
var doNotInitLoader = true;
${inputFile.toString()};
Monaco_Loader_Init = function() {
AMDLoader.init();
CSSLoaderPlugin.init();
NLSLoaderPlugin.init();
return { define, require };
}
})();
`;
const wrappedInputFilepath = path.join(os.tmpdir(), 'wrapped-loader.js');
console.log(wrappedInputFilepath);
fs.writeFileSync(wrappedInputFilepath, wrappedInputFile);
cp.execFileSync(mksnapshot, [wrappedInputFilepath, `--startup_blob`, startupBlobFilepath]);
}
}
================================================
FILE: build/lib/standalone.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const fs = require("fs");
const path = require("path");
const tss = require("./treeshaking");
const REPO_ROOT = path.join(__dirname, '../../');
const SRC_DIR = path.join(REPO_ROOT, 'src');
let dirCache = {};
function writeFile(filePath, contents) {
function ensureDirs(dirPath) {
if (dirCache[dirPath]) {
return;
}
dirCache[dirPath] = true;
ensureDirs(path.dirname(dirPath));
if (fs.existsSync(dirPath)) {
return;
}
fs.mkdirSync(dirPath);
}
ensureDirs(path.dirname(filePath));
fs.writeFileSync(filePath, contents);
}
function extractEditor(options) {
const tsConfig = JSON.parse(fs.readFileSync(path.join(options.sourcesRoot, 'tsconfig.monaco.json')).toString());
let compilerOptions;
if (tsConfig.extends) {
compilerOptions = Object.assign({}, require(path.join(options.sourcesRoot, tsConfig.extends)).compilerOptions, tsConfig.compilerOptions);
delete tsConfig.extends;
}
else {
compilerOptions = tsConfig.compilerOptions;
}
tsConfig.compilerOptions = compilerOptions;
compilerOptions.noEmit = false;
compilerOptions.noUnusedLocals = false;
compilerOptions.preserveConstEnums = false;
compilerOptions.declaration = false;
compilerOptions.moduleResolution = ts.ModuleResolutionKind.Classic;
options.compilerOptions = compilerOptions;
console.log(`Running with shakeLevel ${tss.toStringShakeLevel(options.shakeLevel)}`);
let result = tss.shake(options);
for (let fileName in result) {
if (result.hasOwnProperty(fileName)) {
writeFile(path.join(options.destRoot, fileName), result[fileName]);
}
}
let copied = {};
const copyFile = (fileName) => {
if (copied[fileName]) {
return;
}
copied[fileName] = true;
const srcPath = path.join(options.sourcesRoot, fileName);
const dstPath = path.join(options.destRoot, fileName);
writeFile(dstPath, fs.readFileSync(srcPath));
};
const writeOutputFile = (fileName, contents) => {
writeFile(path.join(options.destRoot, fileName), contents);
};
for (let fileName in result) {
if (result.hasOwnProperty(fileName)) {
const fileContents = result[fileName];
const info = ts.preProcessFile(fileContents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFileName = info.importedFiles[i].fileName;
let importedFilePath;
if (/^vs\/css!/.test(importedFileName)) {
importedFilePath = importedFileName.substr('vs/css!'.length) + '.css';
}
else {
importedFilePath = importedFileName;
}
if (/(^\.\/)|(^\.\.\/)/.test(importedFilePath)) {
importedFilePath = path.join(path.dirname(fileName), importedFilePath);
}
if (/\.css$/.test(importedFilePath)) {
transportCSS(importedFilePath, copyFile, writeOutputFile);
}
else {
if (fs.existsSync(path.join(options.sourcesRoot, importedFilePath + '.js'))) {
copyFile(importedFilePath + '.js');
}
}
}
}
}
delete tsConfig.compilerOptions.moduleResolution;
writeOutputFile('tsconfig.json', JSON.stringify(tsConfig, null, '\t'));
[
'vs/css.build.js',
'vs/css.d.ts',
'vs/css.js',
'vs/loader.js',
'vs/nls.build.js',
'vs/nls.d.ts',
'vs/nls.js',
'vs/nls.mock.ts',
].forEach(copyFile);
}
exports.extractEditor = extractEditor;
function createESMSourcesAndResources2(options) {
const SRC_FOLDER = path.join(REPO_ROOT, options.srcFolder);
const OUT_FOLDER = path.join(REPO_ROOT, options.outFolder);
const OUT_RESOURCES_FOLDER = path.join(REPO_ROOT, options.outResourcesFolder);
const getDestAbsoluteFilePath = (file) => {
let dest = options.renames[file.replace(/\\/g, '/')] || file;
if (dest === 'tsconfig.json') {
return path.join(OUT_FOLDER, `tsconfig.json`);
}
if (/\.ts$/.test(dest)) {
return path.join(OUT_FOLDER, dest);
}
return path.join(OUT_RESOURCES_FOLDER, dest);
};
const allFiles = walkDirRecursive(SRC_FOLDER);
for (const file of allFiles) {
if (options.ignores.indexOf(file.replace(/\\/g, '/')) >= 0) {
continue;
}
if (file === 'tsconfig.json') {
const tsConfig = JSON.parse(fs.readFileSync(path.join(SRC_FOLDER, file)).toString());
tsConfig.compilerOptions.module = 'es6';
tsConfig.compilerOptions.outDir = path.join(path.relative(OUT_FOLDER, OUT_RESOURCES_FOLDER), 'vs').replace(/\\/g, '/');
write(getDestAbsoluteFilePath(file), JSON.stringify(tsConfig, null, '\t'));
continue;
}
if (/\.d\.ts$/.test(file) || /\.css$/.test(file) || /\.js$/.test(file) || /\.ttf$/.test(file)) {
// Transport the files directly
write(getDestAbsoluteFilePath(file), fs.readFileSync(path.join(SRC_FOLDER, file)));
continue;
}
if (/\.ts$/.test(file)) {
// Transform the .ts file
let fileContents = fs.readFileSync(path.join(SRC_FOLDER, file)).toString();
const info = ts.preProcessFile(fileContents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFilename = info.importedFiles[i].fileName;
const pos = info.importedFiles[i].pos;
const end = info.importedFiles[i].end;
let importedFilepath;
if (/^vs\/css!/.test(importedFilename)) {
importedFilepath = importedFilename.substr('vs/css!'.length) + '.css';
}
else {
importedFilepath = importedFilename;
}
if (/(^\.\/)|(^\.\.\/)/.test(importedFilepath)) {
importedFilepath = path.join(path.dirname(file), importedFilepath);
}
let relativePath;
if (importedFilepath === path.dirname(file).replace(/\\/g, '/')) {
relativePath = '../' + path.basename(path.dirname(file));
}
else if (importedFilepath === path.dirname(path.dirname(file)).replace(/\\/g, '/')) {
relativePath = '../../' + path.basename(path.dirname(path.dirname(file)));
}
else {
relativePath = path.relative(path.dirname(file), importedFilepath);
}
relativePath = relativePath.replace(/\\/g, '/');
if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
relativePath = './' + relativePath;
}
fileContents = (fileContents.substring(0, pos + 1)
+ relativePath
+ fileContents.substring(end + 1));
}
fileContents = fileContents.replace(/import ([a-zA-z0-9]+) = require\(('[^']+')\);/g, function (_, m1, m2) {
return `import * as ${m1} from ${m2};`;
});
write(getDestAbsoluteFilePath(file), fileContents);
continue;
}
console.log(`UNKNOWN FILE: ${file}`);
}
function walkDirRecursive(dir) {
if (dir.charAt(dir.length - 1) !== '/' || dir.charAt(dir.length - 1) !== '\\') {
dir += '/';
}
let result = [];
_walkDirRecursive(dir, result, dir.length);
return result;
}
function _walkDirRecursive(dir, result, trimPos) {
const files = fs.readdirSync(dir);
for (let i = 0; i < files.length; i++) {
const file = path.join(dir, files[i]);
if (fs.statSync(file).isDirectory()) {
_walkDirRecursive(file, result, trimPos);
}
else {
result.push(file.substr(trimPos));
}
}
}
function write(absoluteFilePath, contents) {
if (/(\.ts$)|(\.js$)/.test(absoluteFilePath)) {
contents = toggleComments(contents.toString());
}
writeFile(absoluteFilePath, contents);
function toggleComments(fileContents) {
let lines = fileContents.split(/\r\n|\r|\n/);
let mode = 0;
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (mode === 0) {
if (/\/\/ ESM-comment-begin/.test(line)) {
mode = 1;
continue;
}
if (/\/\/ ESM-uncomment-begin/.test(line)) {
mode = 2;
continue;
}
continue;
}
if (mode === 1) {
if (/\/\/ ESM-comment-end/.test(line)) {
mode = 0;
continue;
}
lines[i] = '// ' + line;
continue;
}
if (mode === 2) {
if (/\/\/ ESM-uncomment-end/.test(line)) {
mode = 0;
continue;
}
lines[i] = line.replace(/^(\s*)\/\/ ?/, function (_, indent) {
return indent;
});
}
}
return lines.join('\n');
}
}
}
exports.createESMSourcesAndResources2 = createESMSourcesAndResources2;
function transportCSS(module, enqueue, write) {
if (!/\.css/.test(module)) {
return false;
}
const filename = path.join(SRC_DIR, module);
const fileContents = fs.readFileSync(filename).toString();
const inlineResources = 'base64'; // see https://github.com/Microsoft/monaco-editor/issues/148
const newContents = _rewriteOrInlineUrls(fileContents, inlineResources === 'base64');
write(module, newContents);
return true;
function _rewriteOrInlineUrls(contents, forceBase64) {
return _replaceURL(contents, (url) => {
const fontMatch = url.match(/^(.*).ttf\?(.*)$/);
if (fontMatch) {
const relativeFontPath = `${fontMatch[1]}.ttf`; // trim the query parameter
const fontPath = path.join(path.dirname(module), relativeFontPath);
enqueue(fontPath);
return relativeFontPath;
}
const imagePath = path.join(path.dirname(module), url);
const fileContents = fs.readFileSync(path.join(SRC_DIR, imagePath));
const MIME = /\.svg$/.test(url) ? 'image/svg+xml' : 'image/png';
let DATA = ';base64,' + fileContents.toString('base64');
if (!forceBase64 && /\.svg$/.test(url)) {
// .svg => url encode as explained at https://codepen.io/tigt/post/optimizing-svgs-in-data-uris
let newText = fileContents.toString()
.replace(/"/g, '\'')
.replace(//g, '%3E')
.replace(/&/g, '%26')
.replace(/#/g, '%23')
.replace(/\s+/g, ' ');
let encodedData = ',' + newText;
if (encodedData.length < DATA.length) {
DATA = encodedData;
}
}
return '"data:' + MIME + DATA + '"';
});
}
function _replaceURL(contents, replacer) {
// Use ")" as the terminator as quotes are oftentimes not used at all
return contents.replace(/url\(\s*([^\)]+)\s*\)?/g, (_, ...matches) => {
let url = matches[0];
// Eliminate starting quotes (the initial whitespace is not captured)
if (url.charAt(0) === '"' || url.charAt(0) === '\'') {
url = url.substring(1);
}
// The ending whitespace is captured
while (url.length > 0 && (url.charAt(url.length - 1) === ' ' || url.charAt(url.length - 1) === '\t')) {
url = url.substring(0, url.length - 1);
}
// Eliminate ending quotes
if (url.charAt(url.length - 1) === '"' || url.charAt(url.length - 1) === '\'') {
url = url.substring(0, url.length - 1);
}
if (!_startsWith(url, 'data:') && !_startsWith(url, 'http://') && !_startsWith(url, 'https://')) {
url = replacer(url);
}
return 'url(' + url + ')';
});
}
function _startsWith(haystack, needle) {
return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
}
}
================================================
FILE: build/lib/standalone.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as fs from 'fs';
import * as path from 'path';
import * as tss from './treeshaking';
const REPO_ROOT = path.join(__dirname, '../../');
const SRC_DIR = path.join(REPO_ROOT, 'src');
let dirCache: { [dir: string]: boolean; } = {};
function writeFile(filePath: string, contents: Buffer | string): void {
function ensureDirs(dirPath: string): void {
if (dirCache[dirPath]) {
return;
}
dirCache[dirPath] = true;
ensureDirs(path.dirname(dirPath));
if (fs.existsSync(dirPath)) {
return;
}
fs.mkdirSync(dirPath);
}
ensureDirs(path.dirname(filePath));
fs.writeFileSync(filePath, contents);
}
export function extractEditor(options: tss.ITreeShakingOptions & { destRoot: string }): void {
const tsConfig = JSON.parse(fs.readFileSync(path.join(options.sourcesRoot, 'tsconfig.monaco.json')).toString());
let compilerOptions: { [key: string]: any };
if (tsConfig.extends) {
compilerOptions = Object.assign({}, require(path.join(options.sourcesRoot, tsConfig.extends)).compilerOptions, tsConfig.compilerOptions);
delete tsConfig.extends;
} else {
compilerOptions = tsConfig.compilerOptions;
}
tsConfig.compilerOptions = compilerOptions;
compilerOptions.noEmit = false;
compilerOptions.noUnusedLocals = false;
compilerOptions.preserveConstEnums = false;
compilerOptions.declaration = false;
compilerOptions.moduleResolution = ts.ModuleResolutionKind.Classic;
options.compilerOptions = compilerOptions;
console.log(`Running with shakeLevel ${tss.toStringShakeLevel(options.shakeLevel)}`);
let result = tss.shake(options);
for (let fileName in result) {
if (result.hasOwnProperty(fileName)) {
writeFile(path.join(options.destRoot, fileName), result[fileName]);
}
}
let copied: { [fileName: string]: boolean; } = {};
const copyFile = (fileName: string) => {
if (copied[fileName]) {
return;
}
copied[fileName] = true;
const srcPath = path.join(options.sourcesRoot, fileName);
const dstPath = path.join(options.destRoot, fileName);
writeFile(dstPath, fs.readFileSync(srcPath));
};
const writeOutputFile = (fileName: string, contents: string | Buffer) => {
writeFile(path.join(options.destRoot, fileName), contents);
};
for (let fileName in result) {
if (result.hasOwnProperty(fileName)) {
const fileContents = result[fileName];
const info = ts.preProcessFile(fileContents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFileName = info.importedFiles[i].fileName;
let importedFilePath: string;
if (/^vs\/css!/.test(importedFileName)) {
importedFilePath = importedFileName.substr('vs/css!'.length) + '.css';
} else {
importedFilePath = importedFileName;
}
if (/(^\.\/)|(^\.\.\/)/.test(importedFilePath)) {
importedFilePath = path.join(path.dirname(fileName), importedFilePath);
}
if (/\.css$/.test(importedFilePath)) {
transportCSS(importedFilePath, copyFile, writeOutputFile);
} else {
if (fs.existsSync(path.join(options.sourcesRoot, importedFilePath + '.js'))) {
copyFile(importedFilePath + '.js');
}
}
}
}
}
delete tsConfig.compilerOptions.moduleResolution;
writeOutputFile('tsconfig.json', JSON.stringify(tsConfig, null, '\t'));
[
'vs/css.build.js',
'vs/css.d.ts',
'vs/css.js',
'vs/loader.js',
'vs/nls.build.js',
'vs/nls.d.ts',
'vs/nls.js',
'vs/nls.mock.ts',
].forEach(copyFile);
}
export interface IOptions2 {
srcFolder: string;
outFolder: string;
outResourcesFolder: string;
ignores: string[];
renames: { [filename: string]: string; };
}
export function createESMSourcesAndResources2(options: IOptions2): void {
const SRC_FOLDER = path.join(REPO_ROOT, options.srcFolder);
const OUT_FOLDER = path.join(REPO_ROOT, options.outFolder);
const OUT_RESOURCES_FOLDER = path.join(REPO_ROOT, options.outResourcesFolder);
const getDestAbsoluteFilePath = (file: string): string => {
let dest = options.renames[file.replace(/\\/g, '/')] || file;
if (dest === 'tsconfig.json') {
return path.join(OUT_FOLDER, `tsconfig.json`);
}
if (/\.ts$/.test(dest)) {
return path.join(OUT_FOLDER, dest);
}
return path.join(OUT_RESOURCES_FOLDER, dest);
};
const allFiles = walkDirRecursive(SRC_FOLDER);
for (const file of allFiles) {
if (options.ignores.indexOf(file.replace(/\\/g, '/')) >= 0) {
continue;
}
if (file === 'tsconfig.json') {
const tsConfig = JSON.parse(fs.readFileSync(path.join(SRC_FOLDER, file)).toString());
tsConfig.compilerOptions.module = 'es6';
tsConfig.compilerOptions.outDir = path.join(path.relative(OUT_FOLDER, OUT_RESOURCES_FOLDER), 'vs').replace(/\\/g, '/');
write(getDestAbsoluteFilePath(file), JSON.stringify(tsConfig, null, '\t'));
continue;
}
if (/\.d\.ts$/.test(file) || /\.css$/.test(file) || /\.js$/.test(file) || /\.ttf$/.test(file)) {
// Transport the files directly
write(getDestAbsoluteFilePath(file), fs.readFileSync(path.join(SRC_FOLDER, file)));
continue;
}
if (/\.ts$/.test(file)) {
// Transform the .ts file
let fileContents = fs.readFileSync(path.join(SRC_FOLDER, file)).toString();
const info = ts.preProcessFile(fileContents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFilename = info.importedFiles[i].fileName;
const pos = info.importedFiles[i].pos;
const end = info.importedFiles[i].end;
let importedFilepath: string;
if (/^vs\/css!/.test(importedFilename)) {
importedFilepath = importedFilename.substr('vs/css!'.length) + '.css';
} else {
importedFilepath = importedFilename;
}
if (/(^\.\/)|(^\.\.\/)/.test(importedFilepath)) {
importedFilepath = path.join(path.dirname(file), importedFilepath);
}
let relativePath: string;
if (importedFilepath === path.dirname(file).replace(/\\/g, '/')) {
relativePath = '../' + path.basename(path.dirname(file));
} else if (importedFilepath === path.dirname(path.dirname(file)).replace(/\\/g, '/')) {
relativePath = '../../' + path.basename(path.dirname(path.dirname(file)));
} else {
relativePath = path.relative(path.dirname(file), importedFilepath);
}
relativePath = relativePath.replace(/\\/g, '/');
if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
relativePath = './' + relativePath;
}
fileContents = (
fileContents.substring(0, pos + 1)
+ relativePath
+ fileContents.substring(end + 1)
);
}
fileContents = fileContents.replace(/import ([a-zA-z0-9]+) = require\(('[^']+')\);/g, function (_, m1, m2) {
return `import * as ${m1} from ${m2};`;
});
write(getDestAbsoluteFilePath(file), fileContents);
continue;
}
console.log(`UNKNOWN FILE: ${file}`);
}
function walkDirRecursive(dir: string): string[] {
if (dir.charAt(dir.length - 1) !== '/' || dir.charAt(dir.length - 1) !== '\\') {
dir += '/';
}
let result: string[] = [];
_walkDirRecursive(dir, result, dir.length);
return result;
}
function _walkDirRecursive(dir: string, result: string[], trimPos: number): void {
const files = fs.readdirSync(dir);
for (let i = 0; i < files.length; i++) {
const file = path.join(dir, files[i]);
if (fs.statSync(file).isDirectory()) {
_walkDirRecursive(file, result, trimPos);
} else {
result.push(file.substr(trimPos));
}
}
}
function write(absoluteFilePath: string, contents: string | Buffer): void {
if (/(\.ts$)|(\.js$)/.test(absoluteFilePath)) {
contents = toggleComments(contents.toString());
}
writeFile(absoluteFilePath, contents);
function toggleComments(fileContents: string): string {
let lines = fileContents.split(/\r\n|\r|\n/);
let mode = 0;
for (let i = 0; i < lines.length; i++) {
const line = lines[i];
if (mode === 0) {
if (/\/\/ ESM-comment-begin/.test(line)) {
mode = 1;
continue;
}
if (/\/\/ ESM-uncomment-begin/.test(line)) {
mode = 2;
continue;
}
continue;
}
if (mode === 1) {
if (/\/\/ ESM-comment-end/.test(line)) {
mode = 0;
continue;
}
lines[i] = '// ' + line;
continue;
}
if (mode === 2) {
if (/\/\/ ESM-uncomment-end/.test(line)) {
mode = 0;
continue;
}
lines[i] = line.replace(/^(\s*)\/\/ ?/, function (_, indent) {
return indent;
});
}
}
return lines.join('\n');
}
}
}
function transportCSS(module: string, enqueue: (module: string) => void, write: (path: string, contents: string | Buffer) => void): boolean {
if (!/\.css/.test(module)) {
return false;
}
const filename = path.join(SRC_DIR, module);
const fileContents = fs.readFileSync(filename).toString();
const inlineResources = 'base64'; // see https://github.com/Microsoft/monaco-editor/issues/148
const newContents = _rewriteOrInlineUrls(fileContents, inlineResources === 'base64');
write(module, newContents);
return true;
function _rewriteOrInlineUrls(contents: string, forceBase64: boolean): string {
return _replaceURL(contents, (url) => {
const fontMatch = url.match(/^(.*).ttf\?(.*)$/);
if (fontMatch) {
const relativeFontPath = `${fontMatch[1]}.ttf`; // trim the query parameter
const fontPath = path.join(path.dirname(module), relativeFontPath);
enqueue(fontPath);
return relativeFontPath;
}
const imagePath = path.join(path.dirname(module), url);
const fileContents = fs.readFileSync(path.join(SRC_DIR, imagePath));
const MIME = /\.svg$/.test(url) ? 'image/svg+xml' : 'image/png';
let DATA = ';base64,' + fileContents.toString('base64');
if (!forceBase64 && /\.svg$/.test(url)) {
// .svg => url encode as explained at https://codepen.io/tigt/post/optimizing-svgs-in-data-uris
let newText = fileContents.toString()
.replace(/"/g, '\'')
.replace(//g, '%3E')
.replace(/&/g, '%26')
.replace(/#/g, '%23')
.replace(/\s+/g, ' ');
let encodedData = ',' + newText;
if (encodedData.length < DATA.length) {
DATA = encodedData;
}
}
return '"data:' + MIME + DATA + '"';
});
}
function _replaceURL(contents: string, replacer: (url: string) => string): string {
// Use ")" as the terminator as quotes are oftentimes not used at all
return contents.replace(/url\(\s*([^\)]+)\s*\)?/g, (_: string, ...matches: string[]) => {
let url = matches[0];
// Eliminate starting quotes (the initial whitespace is not captured)
if (url.charAt(0) === '"' || url.charAt(0) === '\'') {
url = url.substring(1);
}
// The ending whitespace is captured
while (url.length > 0 && (url.charAt(url.length - 1) === ' ' || url.charAt(url.length - 1) === '\t')) {
url = url.substring(0, url.length - 1);
}
// Eliminate ending quotes
if (url.charAt(url.length - 1) === '"' || url.charAt(url.length - 1) === '\'') {
url = url.substring(0, url.length - 1);
}
if (!_startsWith(url, 'data:') && !_startsWith(url, 'http://') && !_startsWith(url, 'https://')) {
url = replacer(url);
}
return 'url(' + url + ')';
});
}
function _startsWith(haystack: string, needle: string): boolean {
return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
}
}
================================================
FILE: build/lib/stats.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const es = require("event-stream");
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
const appInsights = require("applicationinsights");
class Entry {
constructor(name, totalCount, totalSize) {
this.name = name;
this.totalCount = totalCount;
this.totalSize = totalSize;
}
toString(pretty) {
if (!pretty) {
if (this.totalCount === 1) {
return `${this.name}: ${this.totalSize} bytes`;
}
else {
return `${this.name}: ${this.totalCount} files with ${this.totalSize} bytes`;
}
}
else {
if (this.totalCount === 1) {
return `Stats for '${ansiColors.grey(this.name)}': ${Math.round(this.totalSize / 1204)}KB`;
}
else {
const count = this.totalCount < 100
? ansiColors.green(this.totalCount.toString())
: ansiColors.red(this.totalCount.toString());
return `Stats for '${ansiColors.grey(this.name)}': ${count} files, ${Math.round(this.totalSize / 1204)}KB`;
}
}
}
}
const _entries = new Map();
function createStatsStream(group, log) {
const entry = new Entry(group, 0, 0);
_entries.set(entry.name, entry);
return es.through(function (data) {
const file = data;
if (typeof file.path === 'string') {
entry.totalCount += 1;
if (Buffer.isBuffer(file.contents)) {
entry.totalSize += file.contents.length;
}
else if (file.stat && typeof file.stat.size === 'number') {
entry.totalSize += file.stat.size;
}
else {
// funky file...
}
}
this.emit('data', data);
}, function () {
if (log) {
if (entry.totalCount === 1) {
fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${Math.round(entry.totalSize / 1204)}KB`);
}
else {
const count = entry.totalCount < 100
? ansiColors.green(entry.totalCount.toString())
: ansiColors.red(entry.totalCount.toString());
fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${count} files, ${Math.round(entry.totalSize / 1204)}KB`);
}
}
this.emit('end');
});
}
exports.createStatsStream = createStatsStream;
function submitAllStats(productJson, commit) {
const sorted = [];
// move entries for single files to the front
_entries.forEach(value => {
if (value.totalCount === 1) {
sorted.unshift(value);
}
else {
sorted.push(value);
}
});
// print to console
for (const entry of sorted) {
console.log(entry.toString(true));
}
// send data as telementry event when the
// product is configured to send telemetry
if (!productJson || !productJson.aiConfig || typeof productJson.aiConfig.asimovKey !== 'string') {
return Promise.resolve(false);
}
return new Promise(resolve => {
try {
const sizes = {};
const counts = {};
for (const entry of sorted) {
sizes[entry.name] = entry.totalSize;
counts[entry.name] = entry.totalCount;
}
appInsights.setup(productJson.aiConfig.asimovKey)
.setAutoCollectConsole(false)
.setAutoCollectExceptions(false)
.setAutoCollectPerformance(false)
.setAutoCollectRequests(false)
.setAutoCollectDependencies(false)
.setAutoDependencyCorrelation(false)
.start();
appInsights.defaultClient.config.endpointUrl = 'https://vortex.data.microsoft.com/collect/v1';
/* __GDPR__
"monacoworkbench/packagemetrics" : {
"commit" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
"size" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
"count" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
}
*/
appInsights.defaultClient.trackEvent({
name: 'monacoworkbench/packagemetrics',
properties: { commit, size: JSON.stringify(sizes), count: JSON.stringify(counts) }
});
appInsights.defaultClient.flush({
callback: () => {
appInsights.dispose();
resolve(true);
}
});
}
catch (err) {
console.error('ERROR sending build stats as telemetry event!');
console.error(err);
resolve(false);
}
});
}
exports.submitAllStats = submitAllStats;
================================================
FILE: build/lib/stats.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as es from 'event-stream';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
import * as File from 'vinyl';
import * as appInsights from 'applicationinsights';
class Entry {
constructor(readonly name: string, public totalCount: number, public totalSize: number) { }
toString(pretty?: boolean): string {
if (!pretty) {
if (this.totalCount === 1) {
return `${this.name}: ${this.totalSize} bytes`;
} else {
return `${this.name}: ${this.totalCount} files with ${this.totalSize} bytes`;
}
} else {
if (this.totalCount === 1) {
return `Stats for '${ansiColors.grey(this.name)}': ${Math.round(this.totalSize / 1204)}KB`;
} else {
const count = this.totalCount < 100
? ansiColors.green(this.totalCount.toString())
: ansiColors.red(this.totalCount.toString());
return `Stats for '${ansiColors.grey(this.name)}': ${count} files, ${Math.round(this.totalSize / 1204)}KB`;
}
}
}
}
const _entries = new Map();
export function createStatsStream(group: string, log?: boolean): es.ThroughStream {
const entry = new Entry(group, 0, 0);
_entries.set(entry.name, entry);
return es.through(function (data) {
const file = data as File;
if (typeof file.path === 'string') {
entry.totalCount += 1;
if (Buffer.isBuffer(file.contents)) {
entry.totalSize += file.contents.length;
} else if (file.stat && typeof file.stat.size === 'number') {
entry.totalSize += file.stat.size;
} else {
// funky file...
}
}
this.emit('data', data);
}, function () {
if (log) {
if (entry.totalCount === 1) {
fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${Math.round(entry.totalSize / 1204)}KB`);
} else {
const count = entry.totalCount < 100
? ansiColors.green(entry.totalCount.toString())
: ansiColors.red(entry.totalCount.toString());
fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${count} files, ${Math.round(entry.totalSize / 1204)}KB`);
}
}
this.emit('end');
});
}
export function submitAllStats(productJson: any, commit: string): Promise {
const sorted: Entry[] = [];
// move entries for single files to the front
_entries.forEach(value => {
if (value.totalCount === 1) {
sorted.unshift(value);
} else {
sorted.push(value);
}
});
// print to console
for (const entry of sorted) {
console.log(entry.toString(true));
}
// send data as telementry event when the
// product is configured to send telemetry
if (!productJson || !productJson.aiConfig || typeof productJson.aiConfig.asimovKey !== 'string') {
return Promise.resolve(false);
}
return new Promise(resolve => {
try {
const sizes: any = {};
const counts: any = {};
for (const entry of sorted) {
sizes[entry.name] = entry.totalSize;
counts[entry.name] = entry.totalCount;
}
appInsights.setup(productJson.aiConfig.asimovKey)
.setAutoCollectConsole(false)
.setAutoCollectExceptions(false)
.setAutoCollectPerformance(false)
.setAutoCollectRequests(false)
.setAutoCollectDependencies(false)
.setAutoDependencyCorrelation(false)
.start();
appInsights.defaultClient.config.endpointUrl = 'https://vortex.data.microsoft.com/collect/v1';
/* __GDPR__
"monacoworkbench/packagemetrics" : {
"commit" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
"size" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
"count" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
}
*/
appInsights.defaultClient.trackEvent({
name: 'monacoworkbench/packagemetrics',
properties: { commit, size: JSON.stringify(sizes), count: JSON.stringify(counts) }
});
appInsights.defaultClient.flush({
callback: () => {
appInsights.dispose();
resolve(true);
}
});
} catch (err) {
console.error('ERROR sending build stats as telemetry event!');
console.error(err);
resolve(false);
}
});
}
================================================
FILE: build/lib/task.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const fancyLog = require("fancy-log");
const ansiColors = require("ansi-colors");
function _isPromise(p) {
if (typeof p.then === 'function') {
return true;
}
return false;
}
function _renderTime(time) {
return `${Math.round(time)} ms`;
}
async function _execute(task) {
const name = task.taskName || task.displayName || ``;
if (!task._tasks) {
fancyLog('Starting', ansiColors.cyan(name), '...');
}
const startTime = process.hrtime();
await _doExecute(task);
const elapsedArr = process.hrtime(startTime);
const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
if (!task._tasks) {
fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.magenta(_renderTime(elapsedNanoseconds / 1e6)));
}
}
async function _doExecute(task) {
// Always invoke as if it were a callback task
return new Promise((resolve, reject) => {
if (task.length === 1) {
// this is a callback task
task((err) => {
if (err) {
return reject(err);
}
resolve();
});
return;
}
const taskResult = task();
if (typeof taskResult === 'undefined') {
// this is a sync task
resolve();
return;
}
if (_isPromise(taskResult)) {
// this is a promise returning task
taskResult.then(resolve, reject);
return;
}
// this is a stream returning task
taskResult.on('end', _ => resolve());
taskResult.on('error', err => reject(err));
});
}
function series(...tasks) {
const result = async () => {
for (let i = 0; i < tasks.length; i++) {
await _execute(tasks[i]);
}
};
result._tasks = tasks;
return result;
}
exports.series = series;
function parallel(...tasks) {
const result = async () => {
await Promise.all(tasks.map(t => _execute(t)));
};
result._tasks = tasks;
return result;
}
exports.parallel = parallel;
function define(name, task) {
if (task._tasks) {
// This is a composite task
const lastTask = task._tasks[task._tasks.length - 1];
if (lastTask._tasks || lastTask.taskName) {
// This is a composite task without a real task function
// => generate a fake task function
return define(name, series(task, () => Promise.resolve()));
}
lastTask.taskName = name;
task.displayName = name;
return task;
}
// This is a simple task
task.taskName = name;
task.displayName = name;
return task;
}
exports.define = define;
================================================
FILE: build/lib/task.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as fancyLog from 'fancy-log';
import * as ansiColors from 'ansi-colors';
export interface BaseTask {
displayName?: string;
taskName?: string;
_tasks?: Task[];
}
export interface PromiseTask extends BaseTask {
(): Promise;
}
export interface StreamTask extends BaseTask {
(): NodeJS.ReadWriteStream;
}
export interface CallbackTask extends BaseTask {
(cb?: (err?: any) => void): void;
}
export type Task = PromiseTask | StreamTask | CallbackTask;
function _isPromise(p: Promise | NodeJS.ReadWriteStream): p is Promise {
if (typeof (p).then === 'function') {
return true;
}
return false;
}
function _renderTime(time: number): string {
return `${Math.round(time)} ms`;
}
async function _execute(task: Task): Promise {
const name = task.taskName || task.displayName || ``;
if (!task._tasks) {
fancyLog('Starting', ansiColors.cyan(name), '...');
}
const startTime = process.hrtime();
await _doExecute(task);
const elapsedArr = process.hrtime(startTime);
const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
if (!task._tasks) {
fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.magenta(_renderTime(elapsedNanoseconds / 1e6)));
}
}
async function _doExecute(task: Task): Promise {
// Always invoke as if it were a callback task
return new Promise((resolve, reject) => {
if (task.length === 1) {
// this is a callback task
task((err) => {
if (err) {
return reject(err);
}
resolve();
});
return;
}
const taskResult = task();
if (typeof taskResult === 'undefined') {
// this is a sync task
resolve();
return;
}
if (_isPromise(taskResult)) {
// this is a promise returning task
taskResult.then(resolve, reject);
return;
}
// this is a stream returning task
taskResult.on('end', _ => resolve());
taskResult.on('error', err => reject(err));
});
}
export function series(...tasks: Task[]): PromiseTask {
const result = async () => {
for (let i = 0; i < tasks.length; i++) {
await _execute(tasks[i]);
}
};
result._tasks = tasks;
return result;
}
export function parallel(...tasks: Task[]): PromiseTask {
const result = async () => {
await Promise.all(tasks.map(t => _execute(t)));
};
result._tasks = tasks;
return result;
}
export function define(name: string, task: Task): Task {
if (task._tasks) {
// This is a composite task
const lastTask = task._tasks[task._tasks.length - 1];
if (lastTask._tasks || lastTask.taskName) {
// This is a composite task without a real task function
// => generate a fake task function
return define(name, series(task, () => Promise.resolve()));
}
lastTask.taskName = name;
task.displayName = name;
return task;
}
// This is a simple task
task.taskName = name;
task.displayName = name;
return task;
}
================================================
FILE: build/lib/test/i18n.test.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require("assert");
const i18n = require("../i18n");
suite('XLF Parser Tests', () => {
const sampleXlf = 'Key #1Key #2 &';
const sampleTranslatedXlf = 'Key #1Кнопка #1Key #2 &Кнопка #2 &';
const originalFilePath = 'vs/base/common/keybinding';
const keys = ['key1', 'key2'];
const messages = ['Key #1', 'Key #2 &'];
const translatedMessages = { key1: 'Кнопка #1', key2: 'Кнопка #2 &' };
test('Keys & messages to XLF conversion', () => {
const xlf = new i18n.XLF('vscode-workbench');
xlf.addFile(originalFilePath, keys, messages);
const xlfString = xlf.toString();
assert.strictEqual(xlfString.replace(/\s{2,}/g, ''), sampleXlf);
});
test('XLF to keys & messages conversion', () => {
i18n.XLF.parse(sampleTranslatedXlf).then(function (resolvedFiles) {
assert.deepEqual(resolvedFiles[0].messages, translatedMessages);
assert.strictEqual(resolvedFiles[0].originalFilePath, originalFilePath);
});
});
test('JSON file source path to Transifex resource match', () => {
const editorProject = 'vscode-editor', workbenchProject = 'vscode-workbench';
const platform = { name: 'vs/platform', project: editorProject }, editorContrib = { name: 'vs/editor/contrib', project: editorProject }, editor = { name: 'vs/editor', project: editorProject }, base = { name: 'vs/base', project: editorProject }, code = { name: 'vs/code', project: workbenchProject }, workbenchParts = { name: 'vs/workbench/contrib/html', project: workbenchProject }, workbenchServices = { name: 'vs/workbench/services/textfile', project: workbenchProject }, workbench = { name: 'vs/workbench', project: workbenchProject };
assert.deepEqual(i18n.getResource('vs/platform/actions/browser/menusExtensionPoint'), platform);
assert.deepEqual(i18n.getResource('vs/editor/contrib/clipboard/browser/clipboard'), editorContrib);
assert.deepEqual(i18n.getResource('vs/editor/common/modes/modesRegistry'), editor);
assert.deepEqual(i18n.getResource('vs/base/common/errorMessage'), base);
assert.deepEqual(i18n.getResource('vs/code/electron-main/window'), code);
assert.deepEqual(i18n.getResource('vs/workbench/contrib/html/browser/webview'), workbenchParts);
assert.deepEqual(i18n.getResource('vs/workbench/services/textfile/node/testFileService'), workbenchServices);
assert.deepEqual(i18n.getResource('vs/workbench/browser/parts/panel/panelActions'), workbench);
});
});
================================================
FILE: build/lib/test/i18n.test.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import assert = require('assert');
import i18n = require('../i18n');
suite('XLF Parser Tests', () => {
const sampleXlf = 'Key #1Key #2 &';
const sampleTranslatedXlf = 'Key #1Кнопка #1Key #2 &Кнопка #2 &';
const originalFilePath = 'vs/base/common/keybinding';
const keys = ['key1', 'key2'];
const messages = ['Key #1', 'Key #2 &'];
const translatedMessages = { key1: 'Кнопка #1', key2: 'Кнопка #2 &' };
test('Keys & messages to XLF conversion', () => {
const xlf = new i18n.XLF('vscode-workbench');
xlf.addFile(originalFilePath, keys, messages);
const xlfString = xlf.toString();
assert.strictEqual(xlfString.replace(/\s{2,}/g, ''), sampleXlf);
});
test('XLF to keys & messages conversion', () => {
i18n.XLF.parse(sampleTranslatedXlf).then(function(resolvedFiles) {
assert.deepEqual(resolvedFiles[0].messages, translatedMessages);
assert.strictEqual(resolvedFiles[0].originalFilePath, originalFilePath);
});
});
test('JSON file source path to Transifex resource match', () => {
const editorProject: string = 'vscode-editor',
workbenchProject: string = 'vscode-workbench';
const platform: i18n.Resource = { name: 'vs/platform', project: editorProject },
editorContrib = { name: 'vs/editor/contrib', project: editorProject },
editor = { name: 'vs/editor', project: editorProject },
base = { name: 'vs/base', project: editorProject },
code = { name: 'vs/code', project: workbenchProject },
workbenchParts = { name: 'vs/workbench/contrib/html', project: workbenchProject },
workbenchServices = { name: 'vs/workbench/services/textfile', project: workbenchProject },
workbench = { name: 'vs/workbench', project: workbenchProject};
assert.deepEqual(i18n.getResource('vs/platform/actions/browser/menusExtensionPoint'), platform);
assert.deepEqual(i18n.getResource('vs/editor/contrib/clipboard/browser/clipboard'), editorContrib);
assert.deepEqual(i18n.getResource('vs/editor/common/modes/modesRegistry'), editor);
assert.deepEqual(i18n.getResource('vs/base/common/errorMessage'), base);
assert.deepEqual(i18n.getResource('vs/code/electron-main/window'), code);
assert.deepEqual(i18n.getResource('vs/workbench/contrib/html/browser/webview'), workbenchParts);
assert.deepEqual(i18n.getResource('vs/workbench/services/textfile/node/testFileService'), workbenchServices);
assert.deepEqual(i18n.getResource('vs/workbench/browser/parts/panel/panelActions'), workbench);
});
});
================================================
FILE: build/lib/treeshaking.js
================================================
/*---------------------------------------------------------------------------------------------
* 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 });
const fs = require("fs");
const path = require("path");
const ts = require("typescript");
const TYPESCRIPT_LIB_FOLDER = path.dirname(require.resolve('typescript/lib/lib.d.ts'));
var ShakeLevel;
(function (ShakeLevel) {
ShakeLevel[ShakeLevel["Files"] = 0] = "Files";
ShakeLevel[ShakeLevel["InnerFile"] = 1] = "InnerFile";
ShakeLevel[ShakeLevel["ClassMembers"] = 2] = "ClassMembers";
})(ShakeLevel = exports.ShakeLevel || (exports.ShakeLevel = {}));
function toStringShakeLevel(shakeLevel) {
switch (shakeLevel) {
case 0 /* Files */:
return 'Files (0)';
case 1 /* InnerFile */:
return 'InnerFile (1)';
case 2 /* ClassMembers */:
return 'ClassMembers (2)';
}
}
exports.toStringShakeLevel = toStringShakeLevel;
function printDiagnostics(diagnostics) {
for (const diag of diagnostics) {
let result = '';
if (diag.file) {
result += `${diag.file.fileName}: `;
}
if (diag.file && diag.start) {
let location = diag.file.getLineAndCharacterOfPosition(diag.start);
result += `- ${location.line + 1},${location.character} - `;
}
result += JSON.stringify(diag.messageText);
console.log(result);
}
}
function shake(options) {
const languageService = createTypeScriptLanguageService(options);
const program = languageService.getProgram();
const globalDiagnostics = program.getGlobalDiagnostics();
if (globalDiagnostics.length > 0) {
printDiagnostics(globalDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
const syntacticDiagnostics = program.getSyntacticDiagnostics();
if (syntacticDiagnostics.length > 0) {
printDiagnostics(syntacticDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
const semanticDiagnostics = program.getSemanticDiagnostics();
if (semanticDiagnostics.length > 0) {
printDiagnostics(semanticDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
markNodes(languageService, options);
return generateResult(languageService, options.shakeLevel);
}
exports.shake = shake;
//#region Discovery, LanguageService & Setup
function createTypeScriptLanguageService(options) {
// Discover referenced files
const FILES = discoverAndReadFiles(options);
// Add fake usage files
options.inlineEntryPoints.forEach((inlineEntryPoint, index) => {
FILES[`inlineEntryPoint.${index}.ts`] = inlineEntryPoint;
});
// Add additional typings
options.typings.forEach((typing) => {
const filePath = path.join(options.sourcesRoot, typing);
FILES[typing] = fs.readFileSync(filePath).toString();
});
// Resolve libs
const RESOLVED_LIBS = {};
options.libs.forEach((filename) => {
const filepath = path.join(TYPESCRIPT_LIB_FOLDER, filename);
RESOLVED_LIBS[`defaultLib:${filename}`] = fs.readFileSync(filepath).toString();
});
const compilerOptions = ts.convertCompilerOptionsFromJson(options.compilerOptions, options.sourcesRoot).options;
const host = new TypeScriptLanguageServiceHost(RESOLVED_LIBS, FILES, compilerOptions);
return ts.createLanguageService(host);
}
/**
* Read imports and follow them until all files have been handled
*/
function discoverAndReadFiles(options) {
const FILES = {};
const in_queue = Object.create(null);
const queue = [];
const enqueue = (moduleId) => {
if (in_queue[moduleId]) {
return;
}
in_queue[moduleId] = true;
queue.push(moduleId);
};
options.entryPoints.forEach((entryPoint) => enqueue(entryPoint));
while (queue.length > 0) {
const moduleId = queue.shift();
const dts_filename = path.join(options.sourcesRoot, moduleId + '.d.ts');
if (fs.existsSync(dts_filename)) {
const dts_filecontents = fs.readFileSync(dts_filename).toString();
FILES[`${moduleId}.d.ts`] = dts_filecontents;
continue;
}
const js_filename = path.join(options.sourcesRoot, moduleId + '.js');
if (fs.existsSync(js_filename)) {
// This is an import for a .js file, so ignore it...
continue;
}
let ts_filename;
if (options.redirects[moduleId]) {
ts_filename = path.join(options.sourcesRoot, options.redirects[moduleId] + '.ts');
}
else {
ts_filename = path.join(options.sourcesRoot, moduleId + '.ts');
}
const ts_filecontents = fs.readFileSync(ts_filename).toString();
const info = ts.preProcessFile(ts_filecontents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFileName = info.importedFiles[i].fileName;
if (options.importIgnorePattern.test(importedFileName)) {
// Ignore vs/css! imports
continue;
}
let importedModuleId = importedFileName;
if (/(^\.\/)|(^\.\.\/)/.test(importedModuleId)) {
importedModuleId = path.join(path.dirname(moduleId), importedModuleId);
}
enqueue(importedModuleId);
}
FILES[`${moduleId}.ts`] = ts_filecontents;
}
return FILES;
}
/**
* A TypeScript language service host
*/
class TypeScriptLanguageServiceHost {
constructor(libs, files, compilerOptions) {
this._libs = libs;
this._files = files;
this._compilerOptions = compilerOptions;
}
// --- language service host ---------------
getCompilationSettings() {
return this._compilerOptions;
}
getScriptFileNames() {
return ([]
.concat(Object.keys(this._libs))
.concat(Object.keys(this._files)));
}
getScriptVersion(_fileName) {
return '1';
}
getProjectVersion() {
return '1';
}
getScriptSnapshot(fileName) {
if (this._files.hasOwnProperty(fileName)) {
return ts.ScriptSnapshot.fromString(this._files[fileName]);
}
else if (this._libs.hasOwnProperty(fileName)) {
return ts.ScriptSnapshot.fromString(this._libs[fileName]);
}
else {
return ts.ScriptSnapshot.fromString('');
}
}
getScriptKind(_fileName) {
return ts.ScriptKind.TS;
}
getCurrentDirectory() {
return '';
}
getDefaultLibFileName(_options) {
return 'defaultLib:lib.d.ts';
}
isDefaultLibFileName(fileName) {
return fileName === this.getDefaultLibFileName(this._compilerOptions);
}
}
//#endregion
//#region Tree Shaking
var NodeColor;
(function (NodeColor) {
NodeColor[NodeColor["White"] = 0] = "White";
NodeColor[NodeColor["Gray"] = 1] = "Gray";
NodeColor[NodeColor["Black"] = 2] = "Black";
})(NodeColor || (NodeColor = {}));
function getColor(node) {
return node.$$$color || 0 /* White */;
}
function setColor(node, color) {
node.$$$color = color;
}
function nodeOrParentIsBlack(node) {
while (node) {
const color = getColor(node);
if (color === 2 /* Black */) {
return true;
}
node = node.parent;
}
return false;
}
function nodeOrChildIsBlack(node) {
if (getColor(node) === 2 /* Black */) {
return true;
}
for (const child of node.getChildren()) {
if (nodeOrChildIsBlack(child)) {
return true;
}
}
return false;
}
function markNodes(languageService, options) {
const program = languageService.getProgram();
if (!program) {
throw new Error('Could not get program from language service');
}
if (options.shakeLevel === 0 /* Files */) {
// Mark all source files Black
program.getSourceFiles().forEach((sourceFile) => {
setColor(sourceFile, 2 /* Black */);
});
return;
}
const black_queue = [];
const gray_queue = [];
const sourceFilesLoaded = {};
function enqueueTopLevelModuleStatements(sourceFile) {
sourceFile.forEachChild((node) => {
if (ts.isImportDeclaration(node)) {
if (!node.importClause && ts.isStringLiteral(node.moduleSpecifier)) {
setColor(node, 2 /* Black */);
enqueueImport(node, node.moduleSpecifier.text);
}
return;
}
if (ts.isExportDeclaration(node)) {
if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
setColor(node, 2 /* Black */);
enqueueImport(node, node.moduleSpecifier.text);
}
return;
}
if (ts.isExpressionStatement(node)
|| ts.isIfStatement(node)
|| ts.isIterationStatement(node, true)
|| ts.isExportAssignment(node)) {
enqueue_black(node);
}
if (ts.isImportEqualsDeclaration(node)) {
if (/export/.test(node.getFullText(sourceFile))) {
// e.g. "export import Severity = BaseSeverity;"
enqueue_black(node);
}
}
});
}
function enqueue_gray(node) {
if (nodeOrParentIsBlack(node) || getColor(node) === 1 /* Gray */) {
return;
}
setColor(node, 1 /* Gray */);
gray_queue.push(node);
}
function enqueue_black(node) {
const previousColor = getColor(node);
if (previousColor === 2 /* Black */) {
return;
}
if (previousColor === 1 /* Gray */) {
// remove from gray queue
gray_queue.splice(gray_queue.indexOf(node), 1);
setColor(node, 0 /* White */);
// add to black queue
enqueue_black(node);
// // move from one queue to the other
// black_queue.push(node);
// setColor(node, NodeColor.Black);
return;
}
if (nodeOrParentIsBlack(node)) {
return;
}
const fileName = node.getSourceFile().fileName;
if (/^defaultLib:/.test(fileName) || /\.d\.ts$/.test(fileName)) {
setColor(node, 2 /* Black */);
return;
}
const sourceFile = node.getSourceFile();
if (!sourceFilesLoaded[sourceFile.fileName]) {
sourceFilesLoaded[sourceFile.fileName] = true;
enqueueTopLevelModuleStatements(sourceFile);
}
if (ts.isSourceFile(node)) {
return;
}
setColor(node, 2 /* Black */);
black_queue.push(node);
if (options.shakeLevel === 2 /* ClassMembers */ && (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isPropertySignature(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node))) {
const references = languageService.getReferencesAtPosition(node.getSourceFile().fileName, node.name.pos + node.name.getLeadingTriviaWidth());
if (references) {
for (let i = 0, len = references.length; i < len; i++) {
const reference = references[i];
const referenceSourceFile = program.getSourceFile(reference.fileName);
if (!referenceSourceFile) {
continue;
}
const referenceNode = getTokenAtPosition(referenceSourceFile, reference.textSpan.start, false, false);
if (ts.isMethodDeclaration(referenceNode.parent)
|| ts.isPropertyDeclaration(referenceNode.parent)
|| ts.isGetAccessor(referenceNode.parent)
|| ts.isSetAccessor(referenceNode.parent)) {
enqueue_gray(referenceNode.parent);
}
}
}
}
}
function enqueueFile(filename) {
const sourceFile = program.getSourceFile(filename);
if (!sourceFile) {
console.warn(`Cannot find source file ${filename}`);
return;
}
enqueue_black(sourceFile);
}
function enqueueImport(node, importText) {
if (options.importIgnorePattern.test(importText)) {
// this import should be ignored
return;
}
const nodeSourceFile = node.getSourceFile();
let fullPath;
if (/(^\.\/)|(^\.\.\/)/.test(importText)) {
fullPath = path.join(path.dirname(nodeSourceFile.fileName), importText) + '.ts';
}
else {
fullPath = importText + '.ts';
}
enqueueFile(fullPath);
}
options.entryPoints.forEach(moduleId => enqueueFile(moduleId + '.ts'));
// Add fake usage files
options.inlineEntryPoints.forEach((_, index) => enqueueFile(`inlineEntryPoint.${index}.ts`));
let step = 0;
const checker = program.getTypeChecker();
while (black_queue.length > 0 || gray_queue.length > 0) {
++step;
let node;
if (step % 100 === 0) {
console.log(`${step}/${step + black_queue.length + gray_queue.length} (${black_queue.length}, ${gray_queue.length})`);
}
if (black_queue.length === 0) {
for (let i = 0; i < gray_queue.length; i++) {
const node = gray_queue[i];
const nodeParent = node.parent;
if ((ts.isClassDeclaration(nodeParent) || ts.isInterfaceDeclaration(nodeParent)) && nodeOrChildIsBlack(nodeParent)) {
gray_queue.splice(i, 1);
black_queue.push(node);
setColor(node, 2 /* Black */);
i--;
}
}
}
if (black_queue.length > 0) {
node = black_queue.shift();
}
else {
// only gray nodes remaining...
break;
}
const nodeSourceFile = node.getSourceFile();
const loop = (node) => {
const [symbol, symbolImportNode] = getRealNodeSymbol(checker, node);
if (symbolImportNode) {
setColor(symbolImportNode, 2 /* Black */);
}
if (symbol && !nodeIsInItsOwnDeclaration(nodeSourceFile, node, symbol)) {
for (let i = 0, len = symbol.declarations.length; i < len; i++) {
const declaration = symbol.declarations[i];
if (ts.isSourceFile(declaration)) {
// Do not enqueue full source files
// (they can be the declaration of a module import)
continue;
}
if (options.shakeLevel === 2 /* ClassMembers */ && (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration))) {
enqueue_black(declaration.name);
for (let j = 0; j < declaration.members.length; j++) {
const member = declaration.members[j];
const memberName = member.name ? member.name.getText() : null;
if (ts.isConstructorDeclaration(member)
|| ts.isConstructSignatureDeclaration(member)
|| ts.isIndexSignatureDeclaration(member)
|| ts.isCallSignatureDeclaration(member)
|| memberName === 'toJSON'
|| memberName === 'toString'
|| memberName === 'dispose' // TODO: keeping all `dispose` methods
|| /^_(.*)Brand$/.test(memberName || '') // TODO: keeping all members ending with `Brand`...
) {
enqueue_black(member);
}
}
// queue the heritage clauses
if (declaration.heritageClauses) {
for (let heritageClause of declaration.heritageClauses) {
enqueue_black(heritageClause);
}
}
}
else {
enqueue_black(declaration);
}
}
}
node.forEachChild(loop);
};
node.forEachChild(loop);
}
}
function nodeIsInItsOwnDeclaration(nodeSourceFile, node, symbol) {
for (let i = 0, len = symbol.declarations.length; i < len; i++) {
const declaration = symbol.declarations[i];
const declarationSourceFile = declaration.getSourceFile();
if (nodeSourceFile === declarationSourceFile) {
if (declaration.pos <= node.pos && node.end <= declaration.end) {
return true;
}
}
}
return false;
}
function generateResult(languageService, shakeLevel) {
const program = languageService.getProgram();
if (!program) {
throw new Error('Could not get program from language service');
}
let result = {};
const writeFile = (filePath, contents) => {
result[filePath] = contents;
};
program.getSourceFiles().forEach((sourceFile) => {
const fileName = sourceFile.fileName;
if (/^defaultLib:/.test(fileName)) {
return;
}
const destination = fileName;
if (/\.d\.ts$/.test(fileName)) {
if (nodeOrChildIsBlack(sourceFile)) {
writeFile(destination, sourceFile.text);
}
return;
}
let text = sourceFile.text;
let result = '';
function keep(node) {
result += text.substring(node.pos, node.end);
}
function write(data) {
result += data;
}
function writeMarkedNodes(node) {
if (getColor(node) === 2 /* Black */) {
return keep(node);
}
// Always keep certain top-level statements
if (ts.isSourceFile(node.parent)) {
if (ts.isExpressionStatement(node) && ts.isStringLiteral(node.expression) && node.expression.text === 'use strict') {
return keep(node);
}
if (ts.isVariableStatement(node) && nodeOrChildIsBlack(node)) {
return keep(node);
}
}
// Keep the entire import in import * as X cases
if (ts.isImportDeclaration(node)) {
if (node.importClause && node.importClause.namedBindings) {
if (ts.isNamespaceImport(node.importClause.namedBindings)) {
if (getColor(node.importClause.namedBindings) === 2 /* Black */) {
return keep(node);
}
}
else {
let survivingImports = [];
for (const importNode of node.importClause.namedBindings.elements) {
if (getColor(importNode) === 2 /* Black */) {
survivingImports.push(importNode.getFullText(sourceFile));
}
}
const leadingTriviaWidth = node.getLeadingTriviaWidth();
const leadingTrivia = sourceFile.text.substr(node.pos, leadingTriviaWidth);
if (survivingImports.length > 0) {
if (node.importClause && node.importClause.name && getColor(node.importClause) === 2 /* Black */) {
return write(`${leadingTrivia}import ${node.importClause.name.text}, {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
}
return write(`${leadingTrivia}import {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
}
else {
if (node.importClause && node.importClause.name && getColor(node.importClause) === 2 /* Black */) {
return write(`${leadingTrivia}import ${node.importClause.name.text} from${node.moduleSpecifier.getFullText(sourceFile)};`);
}
}
}
}
else {
if (node.importClause && getColor(node.importClause) === 2 /* Black */) {
return keep(node);
}
}
}
if (shakeLevel === 2 /* ClassMembers */ && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && nodeOrChildIsBlack(node)) {
let toWrite = node.getFullText();
for (let i = node.members.length - 1; i >= 0; i--) {
const member = node.members[i];
if (getColor(member) === 2 /* Black */ || !member.name) {
// keep method
continue;
}
let pos = member.pos - node.pos;
let end = member.end - node.pos;
toWrite = toWrite.substring(0, pos) + toWrite.substring(end);
}
return write(toWrite);
}
if (ts.isFunctionDeclaration(node)) {
// Do not go inside functions if they haven't been marked
return;
}
node.forEachChild(writeMarkedNodes);
}
if (getColor(sourceFile) !== 2 /* Black */) {
if (!nodeOrChildIsBlack(sourceFile)) {
// none of the elements are reachable => don't write this file at all!
return;
}
sourceFile.forEachChild(writeMarkedNodes);
result += sourceFile.endOfFileToken.getFullText(sourceFile);
}
else {
result = text;
}
writeFile(destination, result);
});
return result;
}
//#endregion
//#region Utils
/**
* Returns the node's symbol and the `import` node (if the symbol resolved from a different module)
*/
function getRealNodeSymbol(checker, node) {
const getPropertySymbolsFromContextualType = ts.getPropertySymbolsFromContextualType;
const getContainingObjectLiteralElement = ts.getContainingObjectLiteralElement;
const getNameFromPropertyName = ts.getNameFromPropertyName;
// Go to the original declaration for cases:
//
// (1) when the aliased symbol was declared in the location(parent).
// (2) when the aliased symbol is originating from an import.
//
function shouldSkipAlias(node, declaration) {
if (node.kind !== ts.SyntaxKind.Identifier) {
return false;
}
if (node.parent === declaration) {
return true;
}
switch (declaration.kind) {
case ts.SyntaxKind.ImportClause:
case ts.SyntaxKind.ImportEqualsDeclaration:
return true;
case ts.SyntaxKind.ImportSpecifier:
return declaration.parent.kind === ts.SyntaxKind.NamedImports;
default:
return false;
}
}
if (!ts.isShorthandPropertyAssignment(node)) {
if (node.getChildCount() !== 0) {
return [null, null];
}
}
const { parent } = node;
let symbol = checker.getSymbolAtLocation(node);
let importNode = null;
// If this is an alias, and the request came at the declaration location
// get the aliased symbol instead. This allows for goto def on an import e.g.
// import {A, B} from "mod";
// to jump to the implementation directly.
if (symbol && symbol.flags & ts.SymbolFlags.Alias && shouldSkipAlias(node, symbol.declarations[0])) {
const aliased = checker.getAliasedSymbol(symbol);
if (aliased.declarations) {
// We should mark the import as visited
importNode = symbol.declarations[0];
symbol = aliased;
}
}
if (symbol) {
// Because name in short-hand property assignment has two different meanings: property name and property value,
// using go-to-definition at such position should go to the variable declaration of the property value rather than
// go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
// is performed at the location of property access, we would like to go to definition of the property in the short-hand
// assignment. This case and others are handled by the following code.
if (node.parent.kind === ts.SyntaxKind.ShorthandPropertyAssignment) {
symbol = checker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
}
// If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
// declaration the symbol (which is itself), we should try to get to the original type of the ObjectBindingPattern
// and return the property declaration for the referenced property.
// For example:
// import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
//
// function bar(onfulfilled: (value: T) => void) { //....}
// interface Test {
// pr/*destination*/op1: number
// }
// bar(({pr/*goto*/op1})=>{});
if (ts.isPropertyName(node) && ts.isBindingElement(parent) && ts.isObjectBindingPattern(parent.parent) &&
(node === (parent.propertyName || parent.name))) {
const name = getNameFromPropertyName(node);
const type = checker.getTypeAtLocation(parent.parent);
if (name && type) {
if (type.isUnion()) {
const prop = type.types[0].getProperty(name);
if (prop) {
symbol = prop;
}
}
else {
const prop = type.getProperty(name);
if (prop) {
symbol = prop;
}
}
}
}
// If the current location we want to find its definition is in an object literal, try to get the contextual type for the
// object literal, lookup the property symbol in the contextual type, and use this for goto-definition.
// For example
// interface Props{
// /*first*/prop1: number
// prop2: boolean
// }
// function Foo(arg: Props) {}
// Foo( { pr/*1*/op1: 10, prop2: false })
const element = getContainingObjectLiteralElement(node);
if (element) {
const contextualType = element && checker.getContextualType(element.parent);
if (contextualType) {
const propertySymbols = getPropertySymbolsFromContextualType(element, checker, contextualType, /*unionSymbolOk*/ false);
if (propertySymbols) {
symbol = propertySymbols[0];
}
}
}
}
if (symbol && symbol.declarations) {
return [symbol, importNode];
}
return [null, null];
}
/** Get the token whose text contains the position */
function getTokenAtPosition(sourceFile, position, allowPositionInLeadingTrivia, includeEndPosition) {
let current = sourceFile;
outer: while (true) {
// find the child that contains 'position'
for (const child of current.getChildren()) {
const start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile, /*includeJsDoc*/ true);
if (start > position) {
// If this child begins after position, then all subsequent children will as well.
break;
}
const end = child.getEnd();
if (position < end || (position === end && (child.kind === ts.SyntaxKind.EndOfFileToken || includeEndPosition))) {
current = child;
continue outer;
}
}
return current;
}
}
================================================
FILE: build/lib/treeshaking.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as fs from 'fs';
import * as path from 'path';
import * as ts from 'typescript';
const TYPESCRIPT_LIB_FOLDER = path.dirname(require.resolve('typescript/lib/lib.d.ts'));
export const enum ShakeLevel {
Files = 0,
InnerFile = 1,
ClassMembers = 2
}
export function toStringShakeLevel(shakeLevel: ShakeLevel): string {
switch(shakeLevel) {
case ShakeLevel.Files:
return 'Files (0)';
case ShakeLevel.InnerFile:
return 'InnerFile (1)';
case ShakeLevel.ClassMembers:
return 'ClassMembers (2)';
}
}
export interface ITreeShakingOptions {
/**
* The full path to the root where sources are.
*/
sourcesRoot: string;
/**
* Module ids.
* e.g. `vs/editor/editor.main` or `index`
*/
entryPoints: string[];
/**
* Inline usages.
*/
inlineEntryPoints: string[];
/**
* TypeScript libs.
* e.g. `lib.d.ts`, `lib.es2015.collection.d.ts`
*/
libs: string[];
/**
* Other .d.ts files
*/
typings: string[];
/**
* TypeScript compiler options.
*/
compilerOptions?: any;
/**
* The shake level to perform.
*/
shakeLevel: ShakeLevel;
/**
* regex pattern to ignore certain imports e.g. `vs/css!` imports
*/
importIgnorePattern: RegExp;
redirects: { [module: string]: string; };
}
export interface ITreeShakingResult {
[file: string]: string;
}
function printDiagnostics(diagnostics: ReadonlyArray): void {
for (const diag of diagnostics) {
let result = '';
if (diag.file) {
result += `${diag.file.fileName}: `;
}
if (diag.file && diag.start) {
let location = diag.file.getLineAndCharacterOfPosition(diag.start);
result += `- ${location.line + 1},${location.character} - `;
}
result += JSON.stringify(diag.messageText);
console.log(result);
}
}
export function shake(options: ITreeShakingOptions): ITreeShakingResult {
const languageService = createTypeScriptLanguageService(options);
const program = languageService.getProgram()!;
const globalDiagnostics = program.getGlobalDiagnostics();
if (globalDiagnostics.length > 0) {
printDiagnostics(globalDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
const syntacticDiagnostics = program.getSyntacticDiagnostics();
if (syntacticDiagnostics.length > 0) {
printDiagnostics(syntacticDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
const semanticDiagnostics = program.getSemanticDiagnostics();
if (semanticDiagnostics.length > 0) {
printDiagnostics(semanticDiagnostics);
throw new Error(`Compilation Errors encountered.`);
}
markNodes(languageService, options);
return generateResult(languageService, options.shakeLevel);
}
//#region Discovery, LanguageService & Setup
function createTypeScriptLanguageService(options: ITreeShakingOptions): ts.LanguageService {
// Discover referenced files
const FILES = discoverAndReadFiles(options);
// Add fake usage files
options.inlineEntryPoints.forEach((inlineEntryPoint, index) => {
FILES[`inlineEntryPoint.${index}.ts`] = inlineEntryPoint;
});
// Add additional typings
options.typings.forEach((typing) => {
const filePath = path.join(options.sourcesRoot, typing);
FILES[typing] = fs.readFileSync(filePath).toString();
});
// Resolve libs
const RESOLVED_LIBS: ILibMap = {};
options.libs.forEach((filename) => {
const filepath = path.join(TYPESCRIPT_LIB_FOLDER, filename);
RESOLVED_LIBS[`defaultLib:${filename}`] = fs.readFileSync(filepath).toString();
});
const compilerOptions = ts.convertCompilerOptionsFromJson(options.compilerOptions, options.sourcesRoot).options;
const host = new TypeScriptLanguageServiceHost(RESOLVED_LIBS, FILES, compilerOptions);
return ts.createLanguageService(host);
}
/**
* Read imports and follow them until all files have been handled
*/
function discoverAndReadFiles(options: ITreeShakingOptions): IFileMap {
const FILES: IFileMap = {};
const in_queue: { [module: string]: boolean; } = Object.create(null);
const queue: string[] = [];
const enqueue = (moduleId: string) => {
if (in_queue[moduleId]) {
return;
}
in_queue[moduleId] = true;
queue.push(moduleId);
};
options.entryPoints.forEach((entryPoint) => enqueue(entryPoint));
while (queue.length > 0) {
const moduleId = queue.shift()!;
const dts_filename = path.join(options.sourcesRoot, moduleId + '.d.ts');
if (fs.existsSync(dts_filename)) {
const dts_filecontents = fs.readFileSync(dts_filename).toString();
FILES[`${moduleId}.d.ts`] = dts_filecontents;
continue;
}
const js_filename = path.join(options.sourcesRoot, moduleId + '.js');
if (fs.existsSync(js_filename)) {
// This is an import for a .js file, so ignore it...
continue;
}
let ts_filename: string;
if (options.redirects[moduleId]) {
ts_filename = path.join(options.sourcesRoot, options.redirects[moduleId] + '.ts');
} else {
ts_filename = path.join(options.sourcesRoot, moduleId + '.ts');
}
const ts_filecontents = fs.readFileSync(ts_filename).toString();
const info = ts.preProcessFile(ts_filecontents);
for (let i = info.importedFiles.length - 1; i >= 0; i--) {
const importedFileName = info.importedFiles[i].fileName;
if (options.importIgnorePattern.test(importedFileName)) {
// Ignore vs/css! imports
continue;
}
let importedModuleId = importedFileName;
if (/(^\.\/)|(^\.\.\/)/.test(importedModuleId)) {
importedModuleId = path.join(path.dirname(moduleId), importedModuleId);
}
enqueue(importedModuleId);
}
FILES[`${moduleId}.ts`] = ts_filecontents;
}
return FILES;
}
interface ILibMap { [libName: string]: string; }
interface IFileMap { [fileName: string]: string; }
/**
* A TypeScript language service host
*/
class TypeScriptLanguageServiceHost implements ts.LanguageServiceHost {
private readonly _libs: ILibMap;
private readonly _files: IFileMap;
private readonly _compilerOptions: ts.CompilerOptions;
constructor(libs: ILibMap, files: IFileMap, compilerOptions: ts.CompilerOptions) {
this._libs = libs;
this._files = files;
this._compilerOptions = compilerOptions;
}
// --- language service host ---------------
getCompilationSettings(): ts.CompilerOptions {
return this._compilerOptions;
}
getScriptFileNames(): string[] {
return (
([] as string[])
.concat(Object.keys(this._libs))
.concat(Object.keys(this._files))
);
}
getScriptVersion(_fileName: string): string {
return '1';
}
getProjectVersion(): string {
return '1';
}
getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
if (this._files.hasOwnProperty(fileName)) {
return ts.ScriptSnapshot.fromString(this._files[fileName]);
} else if (this._libs.hasOwnProperty(fileName)) {
return ts.ScriptSnapshot.fromString(this._libs[fileName]);
} else {
return ts.ScriptSnapshot.fromString('');
}
}
getScriptKind(_fileName: string): ts.ScriptKind {
return ts.ScriptKind.TS;
}
getCurrentDirectory(): string {
return '';
}
getDefaultLibFileName(_options: ts.CompilerOptions): string {
return 'defaultLib:lib.d.ts';
}
isDefaultLibFileName(fileName: string): boolean {
return fileName === this.getDefaultLibFileName(this._compilerOptions);
}
}
//#endregion
//#region Tree Shaking
const enum NodeColor {
White = 0,
Gray = 1,
Black = 2
}
function getColor(node: ts.Node): NodeColor {
return (node).$$$color || NodeColor.White;
}
function setColor(node: ts.Node, color: NodeColor): void {
(node).$$$color = color;
}
function nodeOrParentIsBlack(node: ts.Node): boolean {
while (node) {
const color = getColor(node);
if (color === NodeColor.Black) {
return true;
}
node = node.parent;
}
return false;
}
function nodeOrChildIsBlack(node: ts.Node): boolean {
if (getColor(node) === NodeColor.Black) {
return true;
}
for (const child of node.getChildren()) {
if (nodeOrChildIsBlack(child)) {
return true;
}
}
return false;
}
function markNodes(languageService: ts.LanguageService, options: ITreeShakingOptions) {
const program = languageService.getProgram();
if (!program) {
throw new Error('Could not get program from language service');
}
if (options.shakeLevel === ShakeLevel.Files) {
// Mark all source files Black
program.getSourceFiles().forEach((sourceFile) => {
setColor(sourceFile, NodeColor.Black);
});
return;
}
const black_queue: ts.Node[] = [];
const gray_queue: ts.Node[] = [];
const sourceFilesLoaded: { [fileName: string]: boolean } = {};
function enqueueTopLevelModuleStatements(sourceFile: ts.SourceFile): void {
sourceFile.forEachChild((node: ts.Node) => {
if (ts.isImportDeclaration(node)) {
if (!node.importClause && ts.isStringLiteral(node.moduleSpecifier)) {
setColor(node, NodeColor.Black);
enqueueImport(node, node.moduleSpecifier.text);
}
return;
}
if (ts.isExportDeclaration(node)) {
if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
setColor(node, NodeColor.Black);
enqueueImport(node, node.moduleSpecifier.text);
}
return;
}
if (
ts.isExpressionStatement(node)
|| ts.isIfStatement(node)
|| ts.isIterationStatement(node, true)
|| ts.isExportAssignment(node)
) {
enqueue_black(node);
}
if (ts.isImportEqualsDeclaration(node)) {
if (/export/.test(node.getFullText(sourceFile))) {
// e.g. "export import Severity = BaseSeverity;"
enqueue_black(node);
}
}
});
}
function enqueue_gray(node: ts.Node): void {
if (nodeOrParentIsBlack(node) || getColor(node) === NodeColor.Gray) {
return;
}
setColor(node, NodeColor.Gray);
gray_queue.push(node);
}
function enqueue_black(node: ts.Node): void {
const previousColor = getColor(node);
if (previousColor === NodeColor.Black) {
return;
}
if (previousColor === NodeColor.Gray) {
// remove from gray queue
gray_queue.splice(gray_queue.indexOf(node), 1);
setColor(node, NodeColor.White);
// add to black queue
enqueue_black(node);
// // move from one queue to the other
// black_queue.push(node);
// setColor(node, NodeColor.Black);
return;
}
if (nodeOrParentIsBlack(node)) {
return;
}
const fileName = node.getSourceFile().fileName;
if (/^defaultLib:/.test(fileName) || /\.d\.ts$/.test(fileName)) {
setColor(node, NodeColor.Black);
return;
}
const sourceFile = node.getSourceFile();
if (!sourceFilesLoaded[sourceFile.fileName]) {
sourceFilesLoaded[sourceFile.fileName] = true;
enqueueTopLevelModuleStatements(sourceFile);
}
if (ts.isSourceFile(node)) {
return;
}
setColor(node, NodeColor.Black);
black_queue.push(node);
if (options.shakeLevel === ShakeLevel.ClassMembers && (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isPropertySignature(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node))) {
const references = languageService.getReferencesAtPosition(node.getSourceFile().fileName, node.name.pos + node.name.getLeadingTriviaWidth());
if (references) {
for (let i = 0, len = references.length; i < len; i++) {
const reference = references[i];
const referenceSourceFile = program!.getSourceFile(reference.fileName);
if (!referenceSourceFile) {
continue;
}
const referenceNode = getTokenAtPosition(referenceSourceFile, reference.textSpan.start, false, false);
if (
ts.isMethodDeclaration(referenceNode.parent)
|| ts.isPropertyDeclaration(referenceNode.parent)
|| ts.isGetAccessor(referenceNode.parent)
|| ts.isSetAccessor(referenceNode.parent)
) {
enqueue_gray(referenceNode.parent);
}
}
}
}
}
function enqueueFile(filename: string): void {
const sourceFile = program!.getSourceFile(filename);
if (!sourceFile) {
console.warn(`Cannot find source file ${filename}`);
return;
}
enqueue_black(sourceFile);
}
function enqueueImport(node: ts.Node, importText: string): void {
if (options.importIgnorePattern.test(importText)) {
// this import should be ignored
return;
}
const nodeSourceFile = node.getSourceFile();
let fullPath: string;
if (/(^\.\/)|(^\.\.\/)/.test(importText)) {
fullPath = path.join(path.dirname(nodeSourceFile.fileName), importText) + '.ts';
} else {
fullPath = importText + '.ts';
}
enqueueFile(fullPath);
}
options.entryPoints.forEach(moduleId => enqueueFile(moduleId + '.ts'));
// Add fake usage files
options.inlineEntryPoints.forEach((_, index) => enqueueFile(`inlineEntryPoint.${index}.ts`));
let step = 0;
const checker = program.getTypeChecker();
while (black_queue.length > 0 || gray_queue.length > 0) {
++step;
let node: ts.Node;
if (step % 100 === 0) {
console.log(`${step}/${step + black_queue.length + gray_queue.length} (${black_queue.length}, ${gray_queue.length})`);
}
if (black_queue.length === 0) {
for (let i = 0; i< gray_queue.length; i++) {
const node = gray_queue[i];
const nodeParent = node.parent;
if ((ts.isClassDeclaration(nodeParent) || ts.isInterfaceDeclaration(nodeParent)) && nodeOrChildIsBlack(nodeParent)) {
gray_queue.splice(i, 1);
black_queue.push(node);
setColor(node, NodeColor.Black);
i--;
}
}
}
if (black_queue.length > 0) {
node = black_queue.shift()!;
} else {
// only gray nodes remaining...
break;
}
const nodeSourceFile = node.getSourceFile();
const loop = (node: ts.Node) => {
const [symbol, symbolImportNode] = getRealNodeSymbol(checker, node);
if (symbolImportNode) {
setColor(symbolImportNode, NodeColor.Black);
}
if (symbol && !nodeIsInItsOwnDeclaration(nodeSourceFile, node, symbol)) {
for (let i = 0, len = symbol.declarations.length; i < len; i++) {
const declaration = symbol.declarations[i];
if (ts.isSourceFile(declaration)) {
// Do not enqueue full source files
// (they can be the declaration of a module import)
continue;
}
if (options.shakeLevel === ShakeLevel.ClassMembers && (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration))) {
enqueue_black(declaration.name!);
for (let j = 0; j < declaration.members.length; j++) {
const member = declaration.members[j];
const memberName = member.name ? member.name.getText() : null;
if (
ts.isConstructorDeclaration(member)
|| ts.isConstructSignatureDeclaration(member)
|| ts.isIndexSignatureDeclaration(member)
|| ts.isCallSignatureDeclaration(member)
|| memberName === 'toJSON'
|| memberName === 'toString'
|| memberName === 'dispose'// TODO: keeping all `dispose` methods
|| /^_(.*)Brand$/.test(memberName || '') // TODO: keeping all members ending with `Brand`...
) {
enqueue_black(member);
}
}
// queue the heritage clauses
if (declaration.heritageClauses) {
for (let heritageClause of declaration.heritageClauses) {
enqueue_black(heritageClause);
}
}
} else {
enqueue_black(declaration);
}
}
}
node.forEachChild(loop);
};
node.forEachChild(loop);
}
}
function nodeIsInItsOwnDeclaration(nodeSourceFile: ts.SourceFile, node: ts.Node, symbol: ts.Symbol): boolean {
for (let i = 0, len = symbol.declarations.length; i < len; i++) {
const declaration = symbol.declarations[i];
const declarationSourceFile = declaration.getSourceFile();
if (nodeSourceFile === declarationSourceFile) {
if (declaration.pos <= node.pos && node.end <= declaration.end) {
return true;
}
}
}
return false;
}
function generateResult(languageService: ts.LanguageService, shakeLevel: ShakeLevel): ITreeShakingResult {
const program = languageService.getProgram();
if (!program) {
throw new Error('Could not get program from language service');
}
let result: ITreeShakingResult = {};
const writeFile = (filePath: string, contents: string): void => {
result[filePath] = contents;
};
program.getSourceFiles().forEach((sourceFile) => {
const fileName = sourceFile.fileName;
if (/^defaultLib:/.test(fileName)) {
return;
}
const destination = fileName;
if (/\.d\.ts$/.test(fileName)) {
if (nodeOrChildIsBlack(sourceFile)) {
writeFile(destination, sourceFile.text);
}
return;
}
let text = sourceFile.text;
let result = '';
function keep(node: ts.Node): void {
result += text.substring(node.pos, node.end);
}
function write(data: string): void {
result += data;
}
function writeMarkedNodes(node: ts.Node): void {
if (getColor(node) === NodeColor.Black) {
return keep(node);
}
// Always keep certain top-level statements
if (ts.isSourceFile(node.parent)) {
if (ts.isExpressionStatement(node) && ts.isStringLiteral(node.expression) && node.expression.text === 'use strict') {
return keep(node);
}
if (ts.isVariableStatement(node) && nodeOrChildIsBlack(node)) {
return keep(node);
}
}
// Keep the entire import in import * as X cases
if (ts.isImportDeclaration(node)) {
if (node.importClause && node.importClause.namedBindings) {
if (ts.isNamespaceImport(node.importClause.namedBindings)) {
if (getColor(node.importClause.namedBindings) === NodeColor.Black) {
return keep(node);
}
} else {
let survivingImports: string[] = [];
for (const importNode of node.importClause.namedBindings.elements) {
if (getColor(importNode) === NodeColor.Black) {
survivingImports.push(importNode.getFullText(sourceFile));
}
}
const leadingTriviaWidth = node.getLeadingTriviaWidth();
const leadingTrivia = sourceFile.text.substr(node.pos, leadingTriviaWidth);
if (survivingImports.length > 0) {
if (node.importClause && node.importClause.name && getColor(node.importClause) === NodeColor.Black) {
return write(`${leadingTrivia}import ${node.importClause.name.text}, {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
}
return write(`${leadingTrivia}import {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
} else {
if (node.importClause && node.importClause.name && getColor(node.importClause) === NodeColor.Black) {
return write(`${leadingTrivia}import ${node.importClause.name.text} from${node.moduleSpecifier.getFullText(sourceFile)};`);
}
}
}
} else {
if (node.importClause && getColor(node.importClause) === NodeColor.Black) {
return keep(node);
}
}
}
if (shakeLevel === ShakeLevel.ClassMembers && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && nodeOrChildIsBlack(node)) {
let toWrite = node.getFullText();
for (let i = node.members.length - 1; i >= 0; i--) {
const member = node.members[i];
if (getColor(member) === NodeColor.Black || !member.name) {
// keep method
continue;
}
let pos = member.pos - node.pos;
let end = member.end - node.pos;
toWrite = toWrite.substring(0, pos) + toWrite.substring(end);
}
return write(toWrite);
}
if (ts.isFunctionDeclaration(node)) {
// Do not go inside functions if they haven't been marked
return;
}
node.forEachChild(writeMarkedNodes);
}
if (getColor(sourceFile) !== NodeColor.Black) {
if (!nodeOrChildIsBlack(sourceFile)) {
// none of the elements are reachable => don't write this file at all!
return;
}
sourceFile.forEachChild(writeMarkedNodes);
result += sourceFile.endOfFileToken.getFullText(sourceFile);
} else {
result = text;
}
writeFile(destination, result);
});
return result;
}
//#endregion
//#region Utils
/**
* Returns the node's symbol and the `import` node (if the symbol resolved from a different module)
*/
function getRealNodeSymbol(checker: ts.TypeChecker, node: ts.Node): [ts.Symbol | null, ts.Declaration | null] {
// Use some TypeScript internals to avoid code duplication
type ObjectLiteralElementWithName = ts.ObjectLiteralElement & { name: ts.PropertyName; parent: ts.ObjectLiteralExpression | ts.JsxAttributes };
const getPropertySymbolsFromContextualType: (node: ObjectLiteralElementWithName, checker: ts.TypeChecker, contextualType: ts.Type, unionSymbolOk: boolean) => ReadonlyArray = (ts).getPropertySymbolsFromContextualType;
const getContainingObjectLiteralElement: (node: ts.Node) => ObjectLiteralElementWithName | undefined = (ts).getContainingObjectLiteralElement;
const getNameFromPropertyName: (name: ts.PropertyName) => string | undefined = (ts).getNameFromPropertyName;
// Go to the original declaration for cases:
//
// (1) when the aliased symbol was declared in the location(parent).
// (2) when the aliased symbol is originating from an import.
//
function shouldSkipAlias(node: ts.Node, declaration: ts.Node): boolean {
if (node.kind !== ts.SyntaxKind.Identifier) {
return false;
}
if (node.parent === declaration) {
return true;
}
switch (declaration.kind) {
case ts.SyntaxKind.ImportClause:
case ts.SyntaxKind.ImportEqualsDeclaration:
return true;
case ts.SyntaxKind.ImportSpecifier:
return declaration.parent.kind === ts.SyntaxKind.NamedImports;
default:
return false;
}
}
if (!ts.isShorthandPropertyAssignment(node)) {
if (node.getChildCount() !== 0) {
return [null, null];
}
}
const { parent } = node;
let symbol = checker.getSymbolAtLocation(node);
let importNode: ts.Declaration | null = null;
// If this is an alias, and the request came at the declaration location
// get the aliased symbol instead. This allows for goto def on an import e.g.
// import {A, B} from "mod";
// to jump to the implementation directly.
if (symbol && symbol.flags & ts.SymbolFlags.Alias && shouldSkipAlias(node, symbol.declarations[0])) {
const aliased = checker.getAliasedSymbol(symbol);
if (aliased.declarations) {
// We should mark the import as visited
importNode = symbol.declarations[0];
symbol = aliased;
}
}
if (symbol) {
// Because name in short-hand property assignment has two different meanings: property name and property value,
// using go-to-definition at such position should go to the variable declaration of the property value rather than
// go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
// is performed at the location of property access, we would like to go to definition of the property in the short-hand
// assignment. This case and others are handled by the following code.
if (node.parent.kind === ts.SyntaxKind.ShorthandPropertyAssignment) {
symbol = checker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
}
// If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
// declaration the symbol (which is itself), we should try to get to the original type of the ObjectBindingPattern
// and return the property declaration for the referenced property.
// For example:
// import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
//
// function bar(onfulfilled: (value: T) => void) { //....}
// interface Test {
// pr/*destination*/op1: number
// }
// bar(({pr/*goto*/op1})=>{});
if (ts.isPropertyName(node) && ts.isBindingElement(parent) && ts.isObjectBindingPattern(parent.parent) &&
(node === (parent.propertyName || parent.name))) {
const name = getNameFromPropertyName(node);
const type = checker.getTypeAtLocation(parent.parent);
if (name && type) {
if (type.isUnion()) {
const prop = type.types[0].getProperty(name);
if (prop) {
symbol = prop;
}
} else {
const prop = type.getProperty(name);
if (prop) {
symbol = prop;
}
}
}
}
// If the current location we want to find its definition is in an object literal, try to get the contextual type for the
// object literal, lookup the property symbol in the contextual type, and use this for goto-definition.
// For example
// interface Props{
// /*first*/prop1: number
// prop2: boolean
// }
// function Foo(arg: Props) {}
// Foo( { pr/*1*/op1: 10, prop2: false })
const element = getContainingObjectLiteralElement(node);
if (element) {
const contextualType = element && checker.getContextualType(element.parent);
if (contextualType) {
const propertySymbols = getPropertySymbolsFromContextualType(element, checker, contextualType, /*unionSymbolOk*/ false);
if (propertySymbols) {
symbol = propertySymbols[0];
}
}
}
}
if (symbol && symbol.declarations) {
return [symbol, importNode];
}
return [null, null];
}
/** Get the token whose text contains the position */
function getTokenAtPosition(sourceFile: ts.SourceFile, position: number, allowPositionInLeadingTrivia: boolean, includeEndPosition: boolean): ts.Node {
let current: ts.Node = sourceFile;
outer: while (true) {
// find the child that contains 'position'
for (const child of current.getChildren()) {
const start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile, /*includeJsDoc*/ true);
if (start > position) {
// If this child begins after position, then all subsequent children will as well.
break;
}
const end = child.getEnd();
if (position < end || (position === end && (child.kind === ts.SyntaxKind.EndOfFileToken || includeEndPosition))) {
current = child;
continue outer;
}
}
return current;
}
}
//#endregion
================================================
FILE: build/lib/tslint/abstractGlobalsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const Lint = require("tslint");
class AbstractGlobalsRuleWalker extends Lint.RuleWalker {
constructor(file, program, opts, _config) {
super(file, opts);
this.program = program;
this._config = _config;
}
visitIdentifier(node) {
if (this.getDisallowedGlobals().some(disallowedGlobal => disallowedGlobal === node.text)) {
if (this._config.allowed && this._config.allowed.some(allowed => allowed === node.text)) {
return; // override
}
const checker = this.program.getTypeChecker();
const symbol = checker.getSymbolAtLocation(node);
if (symbol) {
const declarations = symbol.declarations;
if (Array.isArray(declarations) && symbol.declarations.some(declaration => {
if (declaration) {
const parent = declaration.parent;
if (parent) {
const sourceFile = parent.getSourceFile();
if (sourceFile) {
const fileName = sourceFile.fileName;
if (fileName && fileName.indexOf(this.getDefinitionPattern()) >= 0) {
return true;
}
}
}
}
return false;
})) {
this.addFailureAtNode(node, `Cannot use global '${node.text}' in '${this._config.target}'`);
}
}
}
super.visitIdentifier(node);
}
}
exports.AbstractGlobalsRuleWalker = AbstractGlobalsRuleWalker;
================================================
FILE: build/lib/tslint/abstractGlobalsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
interface AbstractGlobalsRuleConfig {
target: string;
allowed: string[];
}
export abstract class AbstractGlobalsRuleWalker extends Lint.RuleWalker {
constructor(file: ts.SourceFile, private program: ts.Program, opts: Lint.IOptions, private _config: AbstractGlobalsRuleConfig) {
super(file, opts);
}
protected abstract getDisallowedGlobals(): string[];
protected abstract getDefinitionPattern(): string;
visitIdentifier(node: ts.Identifier) {
if (this.getDisallowedGlobals().some(disallowedGlobal => disallowedGlobal === node.text)) {
if (this._config.allowed && this._config.allowed.some(allowed => allowed === node.text)) {
return; // override
}
const checker = this.program.getTypeChecker();
const symbol = checker.getSymbolAtLocation(node);
if (symbol) {
const declarations = symbol.declarations;
if (Array.isArray(declarations) && symbol.declarations.some(declaration => {
if (declaration) {
const parent = declaration.parent;
if (parent) {
const sourceFile = parent.getSourceFile();
if (sourceFile) {
const fileName = sourceFile.fileName;
if (fileName && fileName.indexOf(this.getDefinitionPattern()) >= 0) {
return true;
}
}
}
}
return false;
})) {
this.addFailureAtNode(node, `Cannot use global '${node.text}' in '${this._config.target}'`);
}
}
}
super.visitIdentifier(node);
}
}
================================================
FILE: build/lib/tslint/duplicateImportsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = require("path");
const Lint = require("tslint");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions()));
}
}
exports.Rule = Rule;
class ImportPatterns extends Lint.RuleWalker {
constructor(file, opts) {
super(file, opts);
this.imports = Object.create(null);
}
visitImportDeclaration(node) {
let path = node.moduleSpecifier.getText();
// remove quotes
path = path.slice(1, -1);
if (path[0] === '.') {
path = path_1.join(path_1.dirname(node.getSourceFile().fileName), path);
}
if (this.imports[path]) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Duplicate imports for '${path}'.`));
}
this.imports[path] = true;
}
}
================================================
FILE: build/lib/tslint/duplicateImportsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import { join, dirname } from 'path';
import * as Lint from 'tslint';
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions()));
}
}
class ImportPatterns extends Lint.RuleWalker {
private imports: { [path: string]: boolean; } = Object.create(null);
constructor(file: ts.SourceFile, opts: Lint.IOptions) {
super(file, opts);
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
let path = node.moduleSpecifier.getText();
// remove quotes
path = path.slice(1, -1);
if (path[0] === '.') {
path = join(dirname(node.getSourceFile().fileName), path);
}
if (this.imports[path]) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Duplicate imports for '${path}'.`));
}
this.imports[path] = true;
}
}
================================================
FILE: build/lib/tslint/importPatternsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
const minimatch = require("minimatch");
const path_1 = require("path");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions(), config));
}
}
return [];
}
}
exports.Rule = Rule;
class ImportPatterns extends Lint.RuleWalker {
constructor(file, opts, _config) {
super(file, opts);
this._config = _config;
}
visitImportEqualsDeclaration(node) {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
visitImportDeclaration(node) {
this._validateImport(node.moduleSpecifier.getText(), node);
}
visitCallExpression(node) {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
_validateImport(path, node) {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = path_1.join(this.getSourceFile().fileName, path);
}
let restrictions;
if (typeof this._config.restrictions === 'string') {
restrictions = [this._config.restrictions];
}
else {
restrictions = this._config.restrictions;
}
let matched = false;
for (const pattern of restrictions) {
if (minimatch(path, pattern)) {
matched = true;
break;
}
}
if (!matched) {
// None of the restrictions matched
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Imports violates '${restrictions.join(' or ')}' restrictions. See https://github.com/Microsoft/vscode/wiki/Code-Organization`));
}
}
}
================================================
FILE: build/lib/tslint/importPatternsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import * as minimatch from 'minimatch';
import { join } from 'path';
interface ImportPatternsConfig {
target: string;
restrictions: string | string[];
}
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new ImportPatterns(sourceFile, this.getOptions(), config));
}
}
return [];
}
}
class ImportPatterns extends Lint.RuleWalker {
constructor(file: ts.SourceFile, opts: Lint.IOptions, private _config: ImportPatternsConfig) {
super(file, opts);
}
protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
this._validateImport(node.moduleSpecifier.getText(), node);
}
protected visitCallExpression(node: ts.CallExpression): void {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
private _validateImport(path: string, node: ts.Node): void {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = join(this.getSourceFile().fileName, path);
}
let restrictions: string[];
if (typeof this._config.restrictions === 'string') {
restrictions = [this._config.restrictions];
} else {
restrictions = this._config.restrictions;
}
let matched = false;
for (const pattern of restrictions) {
if (minimatch(path, pattern)) {
matched = true;
break;
}
}
if (!matched) {
// None of the restrictions matched
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Imports violates '${restrictions.join(' or ')}' restrictions. See https://github.com/Microsoft/vscode/wiki/Code-Organization`));
}
}
}
================================================
FILE: build/lib/tslint/layeringRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
const path_1 = require("path");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
const parts = path_1.dirname(sourceFile.fileName).split(/\\|\//);
const ruleArgs = this.getOptions().ruleArguments[0];
let config;
for (let i = parts.length - 1; i >= 0; i--) {
if (ruleArgs[parts[i]]) {
config = {
allowed: new Set(ruleArgs[parts[i]]).add(parts[i]),
disallowed: new Set()
};
Object.keys(ruleArgs).forEach(key => {
if (!config.allowed.has(key)) {
config.disallowed.add(key);
}
});
break;
}
}
if (!config) {
return [];
}
return this.applyWithWalker(new LayeringRule(sourceFile, config, this.getOptions()));
}
}
exports.Rule = Rule;
class LayeringRule extends Lint.RuleWalker {
constructor(file, config, opts) {
super(file, opts);
this._config = config;
}
visitImportEqualsDeclaration(node) {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
visitImportDeclaration(node) {
this._validateImport(node.moduleSpecifier.getText(), node);
}
visitCallExpression(node) {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
_validateImport(path, node) {
// remove quotes
path = path.slice(1, -1);
if (path[0] === '.') {
path = path_1.join(path_1.dirname(node.getSourceFile().fileName), path);
}
const parts = path_1.dirname(path).split(/\\|\//);
for (let i = parts.length - 1; i >= 0; i--) {
const part = parts[i];
if (this._config.allowed.has(part)) {
// GOOD - same layer
return;
}
if (this._config.disallowed.has(part)) {
// BAD - wrong layer
const message = `Bad layering. You are not allowed to access '${part}' from here, allowed layers are: [${LayeringRule._print(this._config.allowed)}]`;
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), message));
return;
}
}
}
static _print(set) {
const r = [];
set.forEach(e => r.push(e));
return r.join(', ');
}
}
================================================
FILE: build/lib/tslint/layeringRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import { join, dirname } from 'path';
interface Config {
allowed: Set;
disallowed: Set;
}
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
const parts = dirname(sourceFile.fileName).split(/\\|\//);
const ruleArgs = this.getOptions().ruleArguments[0];
let config: Config | undefined;
for (let i = parts.length - 1; i >= 0; i--) {
if (ruleArgs[parts[i]]) {
config = {
allowed: new Set(ruleArgs[parts[i]]).add(parts[i]),
disallowed: new Set()
};
Object.keys(ruleArgs).forEach(key => {
if (!config!.allowed.has(key)) {
config!.disallowed.add(key);
}
});
break;
}
}
if (!config) {
return [];
}
return this.applyWithWalker(new LayeringRule(sourceFile, config, this.getOptions()));
}
}
class LayeringRule extends Lint.RuleWalker {
private _config: Config;
constructor(file: ts.SourceFile, config: Config, opts: Lint.IOptions) {
super(file, opts);
this._config = config;
}
protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
this._validateImport(node.moduleSpecifier.getText(), node);
}
protected visitCallExpression(node: ts.CallExpression): void {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
private _validateImport(path: string, node: ts.Node): void {
// remove quotes
path = path.slice(1, -1);
if (path[0] === '.') {
path = join(dirname(node.getSourceFile().fileName), path);
}
const parts = dirname(path).split(/\\|\//);
for (let i = parts.length - 1; i >= 0; i--) {
const part = parts[i];
if (this._config.allowed.has(part)) {
// GOOD - same layer
return;
}
if (this._config.disallowed.has(part)) {
// BAD - wrong layer
const message = `Bad layering. You are not allowed to access '${part}' from here, allowed layers are: [${LayeringRule._print(this._config.allowed)}]`;
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), message));
return;
}
}
}
static _print(set: Set): string {
const r: string[] = [];
set.forEach(e => r.push(e));
return r.join(', ');
}
}
================================================
FILE: build/lib/tslint/noDomGlobalsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const Lint = require("tslint");
const minimatch = require("minimatch");
const abstractGlobalsRule_1 = require("./abstractGlobalsRule");
class Rule extends Lint.Rules.TypedRule {
applyWithProgram(sourceFile, program) {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new NoDOMGlobalsRuleWalker(sourceFile, program, this.getOptions(), config));
}
}
return [];
}
}
exports.Rule = Rule;
class NoDOMGlobalsRuleWalker extends abstractGlobalsRule_1.AbstractGlobalsRuleWalker {
getDefinitionPattern() {
return 'lib.dom.d.ts';
}
getDisallowedGlobals() {
// intentionally not complete
return [
"window",
"document",
"HTMLElement"
];
}
}
================================================
FILE: build/lib/tslint/noDomGlobalsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import * as minimatch from 'minimatch';
import { AbstractGlobalsRuleWalker } from './abstractGlobalsRule';
interface NoDOMGlobalsRuleConfig {
target: string;
allowed: string[];
}
export class Rule extends Lint.Rules.TypedRule {
applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new NoDOMGlobalsRuleWalker(sourceFile, program, this.getOptions(), config));
}
}
return [];
}
}
class NoDOMGlobalsRuleWalker extends AbstractGlobalsRuleWalker {
getDefinitionPattern(): string {
return 'lib.dom.d.ts';
}
getDisallowedGlobals(): string[] {
// intentionally not complete
return [
"window",
"document",
"HTMLElement"
];
}
}
================================================
FILE: build/lib/tslint/noNewBufferRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
return this.applyWithWalker(new NewBufferRuleWalker(sourceFile, this.getOptions()));
}
}
exports.Rule = Rule;
class NewBufferRuleWalker extends Lint.RuleWalker {
visitNewExpression(node) {
if (node.expression.kind === ts.SyntaxKind.Identifier && node.expression && node.expression.text === 'Buffer') {
this.addFailureAtNode(node, '`new Buffer` is deprecated. Consider Buffer.From or Buffer.alloc instead.');
}
super.visitNewExpression(node);
}
}
================================================
FILE: build/lib/tslint/noNewBufferRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
export class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithWalker(new NewBufferRuleWalker(sourceFile, this.getOptions()));
}
}
class NewBufferRuleWalker extends Lint.RuleWalker {
visitNewExpression(node: ts.NewExpression) {
if (node.expression.kind === ts.SyntaxKind.Identifier && node.expression && (node.expression as ts.Identifier).text === 'Buffer') {
this.addFailureAtNode(node, '`new Buffer` is deprecated. Consider Buffer.From or Buffer.alloc instead.');
}
super.visitNewExpression(node);
}
}
================================================
FILE: build/lib/tslint/noNlsInStandaloneEditorRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
const path_1 = require("path");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
if (/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.api/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.main/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(sourceFile.fileName)) {
return this.applyWithWalker(new NoNlsInStandaloneEditorRuleWalker(sourceFile, this.getOptions()));
}
return [];
}
}
exports.Rule = Rule;
class NoNlsInStandaloneEditorRuleWalker extends Lint.RuleWalker {
constructor(file, opts) {
super(file, opts);
}
visitImportEqualsDeclaration(node) {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
visitImportDeclaration(node) {
this._validateImport(node.moduleSpecifier.getText(), node);
}
visitCallExpression(node) {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
_validateImport(path, node) {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = path_1.join(this.getSourceFile().fileName, path);
}
if (/vs(\/|\\)nls/.test(path)) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Not allowed to import vs/nls in standalone editor modules. Use standaloneStrings.ts`));
}
}
}
================================================
FILE: build/lib/tslint/noNlsInStandaloneEditorRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import { join } from 'path';
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
if (
/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.api/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.main/.test(sourceFile.fileName)
|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(sourceFile.fileName)
) {
return this.applyWithWalker(new NoNlsInStandaloneEditorRuleWalker(sourceFile, this.getOptions()));
}
return [];
}
}
class NoNlsInStandaloneEditorRuleWalker extends Lint.RuleWalker {
constructor(file: ts.SourceFile, opts: Lint.IOptions) {
super(file, opts);
}
protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
this._validateImport(node.moduleSpecifier.getText(), node);
}
protected visitCallExpression(node: ts.CallExpression): void {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
private _validateImport(path: string, node: ts.Node): void {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = join(this.getSourceFile().fileName, path);
}
if (
/vs(\/|\\)nls/.test(path)
) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Not allowed to import vs/nls in standalone editor modules. Use standaloneStrings.ts`));
}
}
}
================================================
FILE: build/lib/tslint/noNodejsGlobalsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const Lint = require("tslint");
const minimatch = require("minimatch");
const abstractGlobalsRule_1 = require("./abstractGlobalsRule");
class Rule extends Lint.Rules.TypedRule {
applyWithProgram(sourceFile, program) {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new NoNodejsGlobalsRuleWalker(sourceFile, program, this.getOptions(), config));
}
}
return [];
}
}
exports.Rule = Rule;
class NoNodejsGlobalsRuleWalker extends abstractGlobalsRule_1.AbstractGlobalsRuleWalker {
getDefinitionPattern() {
return '@types/node';
}
getDisallowedGlobals() {
// https://nodejs.org/api/globals.html#globals_global_objects
return [
"NodeJS",
"Buffer",
"__dirname",
"__filename",
"clearImmediate",
"exports",
"global",
"module",
"process",
"setImmediate"
];
}
}
================================================
FILE: build/lib/tslint/noNodejsGlobalsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import * as minimatch from 'minimatch';
import { AbstractGlobalsRuleWalker } from './abstractGlobalsRule';
interface NoNodejsGlobalsConfig {
target: string;
allowed: string[];
}
export class Rule extends Lint.Rules.TypedRule {
applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
const configs = this.getOptions().ruleArguments;
for (const config of configs) {
if (minimatch(sourceFile.fileName, config.target)) {
return this.applyWithWalker(new NoNodejsGlobalsRuleWalker(sourceFile, program, this.getOptions(), config));
}
}
return [];
}
}
class NoNodejsGlobalsRuleWalker extends AbstractGlobalsRuleWalker {
getDefinitionPattern(): string {
return '@types/node';
}
getDisallowedGlobals(): string[] {
// https://nodejs.org/api/globals.html#globals_global_objects
return [
"NodeJS",
"Buffer",
"__dirname",
"__filename",
"clearImmediate",
"exports",
"global",
"module",
"process",
"setImmediate"
];
}
}
================================================
FILE: build/lib/tslint/noStandaloneEditorRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
const path_1 = require("path");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
if (/vs(\/|\\)editor/.test(sourceFile.fileName)) {
// the vs/editor folder is allowed to use the standalone editor
return [];
}
return this.applyWithWalker(new NoStandaloneEditorRuleWalker(sourceFile, this.getOptions()));
}
}
exports.Rule = Rule;
class NoStandaloneEditorRuleWalker extends Lint.RuleWalker {
constructor(file, opts) {
super(file, opts);
}
visitImportEqualsDeclaration(node) {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
visitImportDeclaration(node) {
this._validateImport(node.moduleSpecifier.getText(), node);
}
visitCallExpression(node) {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
_validateImport(path, node) {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = path_1.join(this.getSourceFile().fileName, path);
}
if (/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(path)
|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.api/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.main/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(path)) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Not allowed to import standalone editor modules. See https://github.com/Microsoft/vscode/wiki/Code-Organization`));
}
}
}
================================================
FILE: build/lib/tslint/noStandaloneEditorRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import { join } from 'path';
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
if (/vs(\/|\\)editor/.test(sourceFile.fileName)) {
// the vs/editor folder is allowed to use the standalone editor
return [];
}
return this.applyWithWalker(new NoStandaloneEditorRuleWalker(sourceFile, this.getOptions()));
}
}
class NoStandaloneEditorRuleWalker extends Lint.RuleWalker {
constructor(file: ts.SourceFile, opts: Lint.IOptions) {
super(file, opts);
}
protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
if (node.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
this._validateImport(node.moduleReference.expression.getText(), node);
}
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
this._validateImport(node.moduleSpecifier.getText(), node);
}
protected visitCallExpression(node: ts.CallExpression): void {
super.visitCallExpression(node);
// import('foo') statements inside the code
if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
const [path] = node.arguments;
this._validateImport(path.getText(), node);
}
}
private _validateImport(path: string, node: ts.Node): void {
// remove quotes
path = path.slice(1, -1);
// resolve relative paths
if (path[0] === '.') {
path = join(this.getSourceFile().fileName, path);
}
if (
/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(path)
|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.api/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.main/.test(path)
|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(path)
) {
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Not allowed to import standalone editor modules. See https://github.com/Microsoft/vscode/wiki/Code-Organization`));
}
}
}
================================================
FILE: build/lib/tslint/noUnexternalizedStringsRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const ts = require("typescript");
const Lint = require("tslint");
/**
* Implementation of the no-unexternalized-strings rule.
*/
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
if (/\.d.ts$/.test(sourceFile.fileName)) {
return [];
}
return this.applyWithWalker(new NoUnexternalizedStringsRuleWalker(sourceFile, this.getOptions()));
}
}
exports.Rule = Rule;
function isStringLiteral(node) {
return node && node.kind === ts.SyntaxKind.StringLiteral;
}
function isObjectLiteral(node) {
return node && node.kind === ts.SyntaxKind.ObjectLiteralExpression;
}
function isPropertyAssignment(node) {
return node && node.kind === ts.SyntaxKind.PropertyAssignment;
}
class NoUnexternalizedStringsRuleWalker extends Lint.RuleWalker {
constructor(file, opts) {
super(file, opts);
this.signatures = Object.create(null);
this.ignores = Object.create(null);
this.messageIndex = undefined;
this.keyIndex = undefined;
this.usedKeys = Object.create(null);
const options = this.getOptions();
const first = options && options.length > 0 ? options[0] : null;
if (first) {
if (Array.isArray(first.signatures)) {
first.signatures.forEach((signature) => this.signatures[signature] = true);
}
if (Array.isArray(first.ignores)) {
first.ignores.forEach((ignore) => this.ignores[ignore] = true);
}
if (typeof first.messageIndex !== 'undefined') {
this.messageIndex = first.messageIndex;
}
if (typeof first.keyIndex !== 'undefined') {
this.keyIndex = first.keyIndex;
}
}
}
visitSourceFile(node) {
super.visitSourceFile(node);
Object.keys(this.usedKeys).forEach(key => {
// Keys are quoted.
let identifier = key.substr(1, key.length - 2);
if (!NoUnexternalizedStringsRuleWalker.IDENTIFIER.test(identifier)) {
let occurrence = this.usedKeys[key][0];
this.addFailure(this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), `The key ${occurrence.key.getText()} doesn't conform to a valid localize identifier`));
}
const occurrences = this.usedKeys[key];
if (occurrences.length > 1) {
occurrences.forEach(occurrence => {
this.addFailure((this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), `Duplicate key ${occurrence.key.getText()} with different message value.`)));
});
}
});
}
visitStringLiteral(node) {
this.checkStringLiteral(node);
super.visitStringLiteral(node);
}
checkStringLiteral(node) {
const text = node.getText();
const doubleQuoted = text.length >= 2 && text[0] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE && text[text.length - 1] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE;
const info = this.findDescribingParent(node);
// Ignore strings in import and export nodes.
if (info && info.isImport && doubleQuoted) {
const fix = [
Lint.Replacement.replaceFromTo(node.getStart(), 1, '\''),
Lint.Replacement.replaceFromTo(node.getStart() + text.length - 1, 1, '\''),
];
this.addFailureAtNode(node, NoUnexternalizedStringsRuleWalker.ImportFailureMessage, fix);
return;
}
const callInfo = info ? info.callInfo : null;
const functionName = callInfo ? callInfo.callExpression.expression.getText() : null;
if (functionName && this.ignores[functionName]) {
return;
}
if (doubleQuoted && (!callInfo || callInfo.argIndex === -1 || !this.signatures[functionName])) {
const s = node.getText();
const fix = [
Lint.Replacement.replaceFromTo(node.getStart(), node.getWidth(), `nls.localize('KEY-${s.substring(1, s.length - 1)}', ${s})`),
];
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Unexternalized string found: ${node.getText()}`, fix));
return;
}
// We have a single quoted string outside a localize function name.
if (!doubleQuoted && !this.signatures[functionName]) {
return;
}
// We have a string that is a direct argument into the localize call.
const keyArg = callInfo && callInfo.argIndex === this.keyIndex
? callInfo.callExpression.arguments[this.keyIndex]
: null;
if (keyArg) {
if (isStringLiteral(keyArg)) {
this.recordKey(keyArg, this.messageIndex && callInfo ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
}
else if (isObjectLiteral(keyArg)) {
for (const property of keyArg.properties) {
if (isPropertyAssignment(property)) {
const name = property.name.getText();
if (name === 'key') {
const initializer = property.initializer;
if (isStringLiteral(initializer)) {
this.recordKey(initializer, this.messageIndex && callInfo ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
}
break;
}
}
}
}
}
const messageArg = callInfo.callExpression.arguments[this.messageIndex];
if (messageArg && messageArg.kind !== ts.SyntaxKind.StringLiteral) {
this.addFailure(this.createFailure(messageArg.getStart(), messageArg.getWidth(), `Message argument to '${callInfo.callExpression.expression.getText()}' must be a string literal.`));
return;
}
}
recordKey(keyNode, messageNode) {
const text = keyNode.getText();
// We have an empty key
if (text.match(/(['"]) *\1/)) {
if (messageNode) {
this.addFailureAtNode(keyNode, `Key is empty for message: ${messageNode.getText()}`);
}
else {
this.addFailureAtNode(keyNode, `Key is empty.`);
}
return;
}
let occurrences = this.usedKeys[text];
if (!occurrences) {
occurrences = [];
this.usedKeys[text] = occurrences;
}
if (messageNode) {
if (occurrences.some(pair => pair.message ? pair.message.getText() === messageNode.getText() : false)) {
return;
}
}
occurrences.push({ key: keyNode, message: messageNode });
}
findDescribingParent(node) {
let parent;
while ((parent = node.parent)) {
const kind = parent.kind;
if (kind === ts.SyntaxKind.CallExpression) {
const callExpression = parent;
return { callInfo: { callExpression: callExpression, argIndex: callExpression.arguments.indexOf(node) } };
}
else if (kind === ts.SyntaxKind.ImportEqualsDeclaration || kind === ts.SyntaxKind.ImportDeclaration || kind === ts.SyntaxKind.ExportDeclaration) {
return { isImport: true };
}
else if (kind === ts.SyntaxKind.VariableDeclaration || kind === ts.SyntaxKind.FunctionDeclaration || kind === ts.SyntaxKind.PropertyDeclaration
|| kind === ts.SyntaxKind.MethodDeclaration || kind === ts.SyntaxKind.VariableDeclarationList || kind === ts.SyntaxKind.InterfaceDeclaration
|| kind === ts.SyntaxKind.ClassDeclaration || kind === ts.SyntaxKind.EnumDeclaration || kind === ts.SyntaxKind.ModuleDeclaration
|| kind === ts.SyntaxKind.TypeAliasDeclaration || kind === ts.SyntaxKind.SourceFile) {
return null;
}
node = parent;
}
return null;
}
}
NoUnexternalizedStringsRuleWalker.ImportFailureMessage = 'Do not use double quotes for imports.';
NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE = '"';
NoUnexternalizedStringsRuleWalker.IDENTIFIER = /^[_a-zA-Z0-9][ .\-_a-zA-Z0-9]*$/;
================================================
FILE: build/lib/tslint/noUnexternalizedStringsRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
/**
* Implementation of the no-unexternalized-strings rule.
*/
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
if (/\.d.ts$/.test(sourceFile.fileName)) {
return [];
}
return this.applyWithWalker(new NoUnexternalizedStringsRuleWalker(sourceFile, this.getOptions()));
}
}
interface Map {
[key: string]: V;
}
interface UnexternalizedStringsOptions {
signatures?: string[];
messageIndex?: number;
keyIndex?: number;
ignores?: string[];
}
function isStringLiteral(node: ts.Node): node is ts.StringLiteral {
return node && node.kind === ts.SyntaxKind.StringLiteral;
}
function isObjectLiteral(node: ts.Node): node is ts.ObjectLiteralExpression {
return node && node.kind === ts.SyntaxKind.ObjectLiteralExpression;
}
function isPropertyAssignment(node: ts.Node): node is ts.PropertyAssignment {
return node && node.kind === ts.SyntaxKind.PropertyAssignment;
}
interface KeyMessagePair {
key: ts.StringLiteral;
message: ts.Node | undefined;
}
class NoUnexternalizedStringsRuleWalker extends Lint.RuleWalker {
private static ImportFailureMessage = 'Do not use double quotes for imports.';
private static DOUBLE_QUOTE: string = '"';
private signatures: Map;
private messageIndex: number | undefined;
private keyIndex: number | undefined;
private ignores: Map;
private usedKeys: Map;
constructor(file: ts.SourceFile, opts: Lint.IOptions) {
super(file, opts);
this.signatures = Object.create(null);
this.ignores = Object.create(null);
this.messageIndex = undefined;
this.keyIndex = undefined;
this.usedKeys = Object.create(null);
const options: any[] = this.getOptions();
const first: UnexternalizedStringsOptions = options && options.length > 0 ? options[0] : null;
if (first) {
if (Array.isArray(first.signatures)) {
first.signatures.forEach((signature: string) => this.signatures[signature] = true);
}
if (Array.isArray(first.ignores)) {
first.ignores.forEach((ignore: string) => this.ignores[ignore] = true);
}
if (typeof first.messageIndex !== 'undefined') {
this.messageIndex = first.messageIndex;
}
if (typeof first.keyIndex !== 'undefined') {
this.keyIndex = first.keyIndex;
}
}
}
private static IDENTIFIER = /^[_a-zA-Z0-9][ .\-_a-zA-Z0-9]*$/;
protected visitSourceFile(node: ts.SourceFile): void {
super.visitSourceFile(node);
Object.keys(this.usedKeys).forEach(key => {
// Keys are quoted.
let identifier = key.substr(1, key.length - 2);
if (!NoUnexternalizedStringsRuleWalker.IDENTIFIER.test(identifier)) {
let occurrence = this.usedKeys[key][0];
this.addFailure(this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), `The key ${occurrence.key.getText()} doesn't conform to a valid localize identifier`));
}
const occurrences = this.usedKeys[key];
if (occurrences.length > 1) {
occurrences.forEach(occurrence => {
this.addFailure((this.createFailure(occurrence.key.getStart(), occurrence.key.getWidth(), `Duplicate key ${occurrence.key.getText()} with different message value.`)));
});
}
});
}
protected visitStringLiteral(node: ts.StringLiteral): void {
this.checkStringLiteral(node);
super.visitStringLiteral(node);
}
private checkStringLiteral(node: ts.StringLiteral): void {
const text = node.getText();
const doubleQuoted = text.length >= 2 && text[0] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE && text[text.length - 1] === NoUnexternalizedStringsRuleWalker.DOUBLE_QUOTE;
const info = this.findDescribingParent(node);
// Ignore strings in import and export nodes.
if (info && info.isImport && doubleQuoted) {
const fix = [
Lint.Replacement.replaceFromTo(node.getStart(), 1, '\''),
Lint.Replacement.replaceFromTo(node.getStart() + text.length - 1, 1, '\''),
];
this.addFailureAtNode(
node,
NoUnexternalizedStringsRuleWalker.ImportFailureMessage,
fix
);
return;
}
const callInfo = info ? info.callInfo : null;
const functionName = callInfo ? callInfo.callExpression.expression.getText() : null;
if (functionName && this.ignores[functionName]) {
return;
}
if (doubleQuoted && (!callInfo || callInfo.argIndex === -1 || !this.signatures[functionName!])) {
const s = node.getText();
const fix = [
Lint.Replacement.replaceFromTo(node.getStart(), node.getWidth(), `nls.localize('KEY-${s.substring(1, s.length - 1)}', ${s})`),
];
this.addFailure(this.createFailure(node.getStart(), node.getWidth(), `Unexternalized string found: ${node.getText()}`, fix));
return;
}
// We have a single quoted string outside a localize function name.
if (!doubleQuoted && !this.signatures[functionName!]) {
return;
}
// We have a string that is a direct argument into the localize call.
const keyArg: ts.Expression | null = callInfo && callInfo.argIndex === this.keyIndex
? callInfo.callExpression.arguments[this.keyIndex]
: null;
if (keyArg) {
if (isStringLiteral(keyArg)) {
this.recordKey(keyArg, this.messageIndex && callInfo ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
} else if (isObjectLiteral(keyArg)) {
for (const property of keyArg.properties) {
if (isPropertyAssignment(property)) {
const name = property.name.getText();
if (name === 'key') {
const initializer = property.initializer;
if (isStringLiteral(initializer)) {
this.recordKey(initializer, this.messageIndex && callInfo ? callInfo.callExpression.arguments[this.messageIndex] : undefined);
}
break;
}
}
}
}
}
const messageArg = callInfo!.callExpression.arguments[this.messageIndex!];
if (messageArg && messageArg.kind !== ts.SyntaxKind.StringLiteral) {
this.addFailure(this.createFailure(
messageArg.getStart(), messageArg.getWidth(),
`Message argument to '${callInfo!.callExpression.expression.getText()}' must be a string literal.`));
return;
}
}
private recordKey(keyNode: ts.StringLiteral, messageNode: ts.Node | undefined) {
const text = keyNode.getText();
// We have an empty key
if (text.match(/(['"]) *\1/)) {
if (messageNode) {
this.addFailureAtNode(keyNode, `Key is empty for message: ${messageNode.getText()}`);
} else {
this.addFailureAtNode(keyNode, `Key is empty.`);
}
return;
}
let occurrences: KeyMessagePair[] = this.usedKeys[text];
if (!occurrences) {
occurrences = [];
this.usedKeys[text] = occurrences;
}
if (messageNode) {
if (occurrences.some(pair => pair.message ? pair.message.getText() === messageNode.getText() : false)) {
return;
}
}
occurrences.push({ key: keyNode, message: messageNode });
}
private findDescribingParent(node: ts.Node): { callInfo?: { callExpression: ts.CallExpression, argIndex: number }, isImport?: boolean; } | null {
let parent: ts.Node;
while ((parent = node.parent)) {
const kind = parent.kind;
if (kind === ts.SyntaxKind.CallExpression) {
const callExpression = parent as ts.CallExpression;
return { callInfo: { callExpression: callExpression, argIndex: callExpression.arguments.indexOf(node) } };
} else if (kind === ts.SyntaxKind.ImportEqualsDeclaration || kind === ts.SyntaxKind.ImportDeclaration || kind === ts.SyntaxKind.ExportDeclaration) {
return { isImport: true };
} else if (kind === ts.SyntaxKind.VariableDeclaration || kind === ts.SyntaxKind.FunctionDeclaration || kind === ts.SyntaxKind.PropertyDeclaration
|| kind === ts.SyntaxKind.MethodDeclaration || kind === ts.SyntaxKind.VariableDeclarationList || kind === ts.SyntaxKind.InterfaceDeclaration
|| kind === ts.SyntaxKind.ClassDeclaration || kind === ts.SyntaxKind.EnumDeclaration || kind === ts.SyntaxKind.ModuleDeclaration
|| kind === ts.SyntaxKind.TypeAliasDeclaration || kind === ts.SyntaxKind.SourceFile) {
return null;
}
node = parent;
}
return null;
}
}
================================================
FILE: build/lib/tslint/translationRemindRule.js
================================================
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
const Lint = require("tslint");
const fs = require("fs");
class Rule extends Lint.Rules.AbstractRule {
apply(sourceFile) {
return this.applyWithWalker(new TranslationRemindRuleWalker(sourceFile, this.getOptions()));
}
}
exports.Rule = Rule;
class TranslationRemindRuleWalker extends Lint.RuleWalker {
constructor(file, opts) {
super(file, opts);
}
visitImportDeclaration(node) {
const declaration = node.moduleSpecifier.getText();
if (declaration !== `'${TranslationRemindRuleWalker.NLS_MODULE}'`) {
return;
}
this.visitImportLikeDeclaration(node);
}
visitImportEqualsDeclaration(node) {
const reference = node.moduleReference.getText();
if (reference !== `require('${TranslationRemindRuleWalker.NLS_MODULE}')`) {
return;
}
this.visitImportLikeDeclaration(node);
}
visitImportLikeDeclaration(node) {
const currentFile = node.getSourceFile().fileName;
const matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
const matchPart = currentFile.match(/vs\/workbench\/contrib\/\w+/);
if (!matchService && !matchPart) {
return;
}
const resource = matchService ? matchService[0] : matchPart[0];
let resourceDefined = false;
let json;
try {
json = fs.readFileSync('./build/lib/i18n.resources.json', 'utf8');
}
catch (e) {
console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
return;
}
const workbenchResources = JSON.parse(json).workbench;
workbenchResources.forEach((existingResource) => {
if (existingResource.name === resource) {
resourceDefined = true;
return;
}
});
if (!resourceDefined) {
this.addFailureAtNode(node, `Please add '${resource}' to ./build/lib/i18n.resources.json file to use translations here.`);
}
}
}
TranslationRemindRuleWalker.NLS_MODULE = 'vs/nls';
================================================
FILE: build/lib/tslint/translationRemindRule.ts
================================================
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as ts from 'typescript';
import * as Lint from 'tslint';
import * as fs from 'fs';
export class Rule extends Lint.Rules.AbstractRule {
public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
return this.applyWithWalker(new TranslationRemindRuleWalker(sourceFile, this.getOptions()));
}
}
class TranslationRemindRuleWalker extends Lint.RuleWalker {
private static NLS_MODULE: string = 'vs/nls';
constructor(file: ts.SourceFile, opts: Lint.IOptions) {
super(file, opts);
}
protected visitImportDeclaration(node: ts.ImportDeclaration): void {
const declaration = node.moduleSpecifier.getText();
if (declaration !== `'${TranslationRemindRuleWalker.NLS_MODULE}'`) {
return;
}
this.visitImportLikeDeclaration(node);
}
protected visitImportEqualsDeclaration(node: ts.ImportEqualsDeclaration): void {
const reference = node.moduleReference.getText();
if (reference !== `require('${TranslationRemindRuleWalker.NLS_MODULE}')`) {
return;
}
this.visitImportLikeDeclaration(node);
}
private visitImportLikeDeclaration(node: ts.ImportDeclaration | ts.ImportEqualsDeclaration) {
const currentFile = node.getSourceFile().fileName;
const matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
const matchPart = currentFile.match(/vs\/workbench\/contrib\/\w+/);
if (!matchService && !matchPart) {
return;
}
const resource = matchService ? matchService[0] : matchPart![0];
let resourceDefined = false;
let json;
try {
json = fs.readFileSync('./build/lib/i18n.resources.json', 'utf8');
} catch (e) {
console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
return;
}
const workbenchResources = JSON.parse(json).workbench;
workbenchResources.forEach((existingResource: any) => {
if (existingResource.name === resource) {
resourceDefined = true;
return;
}
});
if (!resourceDefined) {
this.addFailureAtNode(node, `Please add '${resource}' to ./build/lib/i18n.resources.json file to use translations here.`);
}
}
}
================================================
FILE: build/lib/typings/cgmanifest.json
================================================
{
"registrations": [
{
"component": {
"type": "git",
"git": {
"name": "definitelytyped",
"repositoryUrl": "https://github.com/DefinitelyTyped/DefinitelyTyped",
"commitHash": "69e3ac6bec3008271f76bbfa7cf69aa9198c4ff0"
}
},
"license": "MIT"
}
],
"version": 1
}
================================================
FILE: build/lib/typings/event-stream.d.ts
================================================
declare module "event-stream" {
import { Stream } from 'stream';
import { ThroughStream as _ThroughStream } from 'through';
import * as File from 'vinyl';
export interface ThroughStream extends _ThroughStream {
queue(data: File | null): any;
push(data: File | null): any;
paused: boolean;
}
function merge(streams: Stream[]): ThroughStream;
function merge(...streams: Stream[]): ThroughStream;
function concat(...stream: Stream[]): ThroughStream;
function duplex(istream: Stream, ostream: Stream): ThroughStream;
function through(write?: (this: ThroughStream, data: any) => void, end?: (this: ThroughStream) => void,
opts?: { autoDestroy: boolean; }): ThroughStream;
function readArray(array: T[]): ThroughStream;
function writeArray(cb: (err: Error, array: T[]) => void): ThroughStream;
function mapSync(cb: (data: I) => O): ThroughStream;
function map(cb: (data: I, cb: (err?: Error, data?: O) => void) => O): ThroughStream;
function readable(asyncFunction: (this: ThroughStream, ...args: any[]) => any): any;
}
================================================
FILE: build/lib/typings/github-releases.d.ts
================================================
declare module 'github-releases' {
}
================================================
FILE: build/lib/typings/gulp-bom.d.ts
================================================
declare module "gulp-bom" {
function f(): NodeJS.ReadWriteStream;
/**
* This is required as per:
* https://github.com/Microsoft/TypeScript/issues/5073
*/
namespace f {}
export = f;
}
================================================
FILE: build/lib/typings/gulp-cssnano.d.ts
================================================
declare module "gulp-cssnano" {
function f(opts:{reduceIdents:boolean;}): NodeJS.ReadWriteStream;
/**
* This is required as per:
* https://github.com/Microsoft/TypeScript/issues/5073
*/
namespace f {}
export = f;
}
================================================
FILE: build/lib/typings/gulp-flatmap.d.ts
================================================
declare module 'gulp-flatmap' {
import File = require('vinyl');
function f(fn:(stream:NodeJS.ReadWriteStream, file:File)=>NodeJS.ReadWriteStream): NodeJS.ReadWriteStream;
/**
* This is required as per:
* https://github.com/Microsoft/TypeScript/issues/5073
*/
namespace f {}
export = f;
}
================================================
FILE: build/lib/typings/gulp-remote-src.d.ts
================================================
declare module 'gulp-remote-retry-src' {
import stream = require("stream");
function remote(url: string, options: remote.IOptions): stream.Stream;
module remote {
export interface IRequestOptions {
body?: any;
json?: boolean;
method?: string;
headers?: any;
}
export interface IOptions {
base?: string;
buffer?: boolean;
requestOptions?: IRequestOptions;
}
}
export = remote;
}
================================================
FILE: build/lib/typings/gulp-tsb.d.ts
================================================
declare module "gulp-tsb" {
export interface ICancellationToken {
isCancellationRequested(): boolean;
}
export interface IncrementalCompiler {
(token?: ICancellationToken): NodeJS.ReadWriteStream;
src(opts?: {
cwd?: string;
base?: string;
}): NodeJS.ReadStream;
}
export function create(projectPath: string, existingOptions: any, verbose?: boolean, onError?: (message: any) => void): IncrementalCompiler;
}
================================================
FILE: build/lib/typings/is.d.ts
================================================
declare module 'is' {
function a(value: any, type: string): boolean;
function defined(value: any): boolean;
function undef(value: any): boolean;
function object(value: any): boolean;
function string(value: any): value is string;
function boolean(value: any): boolean;
function array(value: any): boolean;
function empty(value: Object | Array): boolean;
function equal | Function | Date>(value: T, other: T): boolean;
}
================================================
FILE: build/lib/typings/lazy.js.d.ts
================================================
// Type definitions for Lazy.js 0.3.2
// Project: https://github.com/dtao/lazy.js/
// Definitions by: Bart van der Schoor
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare function Lazy(value: string): Lazy.StringLikeSequence;
declare function Lazy(value: T[]): Lazy.ArrayLikeSequence;
declare function Lazy(value: any[]): Lazy.ArrayLikeSequence;
declare function Lazy(value: Object): Lazy.ObjectLikeSequence;
declare function Lazy(value: Object): Lazy.ObjectLikeSequence;
declare module Lazy {
function strict(): StrictLazy;
function generate(generatorFn: GeneratorCallback, length?: number): GeneratedSequence;
function range(to: number): GeneratedSequence;
function range(from: number, to: number, step?: number): GeneratedSequence;
function repeat(value: T, count?: number): GeneratedSequence;
function on(eventType: string): Sequence;
function readFile(path: string): StringLikeSequence;
function makeHttpRequest(path: string): StringLikeSequence;
interface StrictLazy {
(value: string): StringLikeSequence;
(value: T[]): ArrayLikeSequence;
(value: any[]): ArrayLikeSequence;
(value: Object): ObjectLikeSequence;
(value: Object): ObjectLikeSequence;
strict(): StrictLazy;
generate(generatorFn: GeneratorCallback, length?: number): GeneratedSequence;
range(to: number): GeneratedSequence;
range(from: number, to: number, step?: number): GeneratedSequence;
repeat(value: T, count?: number): GeneratedSequence;
on(eventType: string): Sequence;
readFile(path: string): StringLikeSequence;
makeHttpRequest(path: string): StringLikeSequence;
}
interface ArrayLike {
length: number;
[index: number]: T;
}
interface Callback {
(): void;
}
interface ErrorCallback {
(error: any): void;
}
interface ValueCallback {
(value: T): void;
}
interface GetKeyCallback {
(value: T): string;
}
interface TestCallback {
(value: T): boolean;
}
interface MapCallback {
(value: T): U;
}
interface MapStringCallback {
(value: string): string;
}
interface NumberCallback {
(value: T): number;
}
interface MemoCallback {
(memo: U, value: T): U;
}
interface GeneratorCallback {
(index: number): T;
}
interface CompareCallback {
(x: any, y: any): number;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
interface Iterator {
new(sequence: Sequence): Iterator;
current(): T;
moveNext(): boolean;
}
interface GeneratedSequence extends Sequence {
new(generatorFn: GeneratorCallback, length: number): GeneratedSequence;
length(): number;
}
interface AsyncSequence extends SequenceBase {
each(callback: ValueCallback): AsyncHandle;
}
interface AsyncHandle {
cancel(): void;
onComplete(callback: Callback): void;
onError(callback: ErrorCallback): void;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
module Sequence {
function define(methodName: string[], overrides: Object): Function;
}
interface Sequence extends SequenceBase {
each(eachFn: ValueCallback): Sequence;
}
interface ArraySequence extends SequenceBase {
flatten(): Sequence;
}
interface SequenceBase extends SequenceBaser {
first(): any;
first(count: number): Sequence;
indexOf(value: any, startIndex?: number): Sequence;
last(): any;
last(count: number): Sequence;
lastIndexOf(value: any): Sequence;
reverse(): Sequence;
}
interface SequenceBaser {
// TODO improve define() (needs ugly overload)
async(interval: number): AsyncSequence;
chunk(size: number): Sequence;
compact(): Sequence;
concat(var_args: T[]): Sequence;
concat(sequence: Sequence): Sequence;
consecutive(length: number): Sequence;
contains(value: T): boolean;
countBy(keyFn: GetKeyCallback): ObjectLikeSequence;
countBy(propertyName: string): ObjectLikeSequence;
dropWhile(predicateFn: TestCallback): Sequence;
every(predicateFn: TestCallback): boolean;
filter(predicateFn: TestCallback): Sequence