Dossier complet

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/.signature

@@ -0,0 +1,5 @@
+{
+  "timestamp": 1644227810,
+  "signature": "J2ERXR1rcMZDzxM3RPHy7XwJAhoGSk6/gtAwogwLgqehD8ZWzFeQcgXDWT45E26Yi/g0inNl427PuSj5DVj6Z1gxKhhsurLprut7smt3sC09dk1x3Do1s1ufl9LOMveDO0xJji1yxoKDPDYRK6Lmuwi7E27XbtgG445xOARUdBPfsSpQMjKFpLZnQFYOQoKvPnty2HJt+YlWBVwXiDNYZkNF0PLPULVcPSBRbmU/yI8RH6uDfBb2B2UcbfloaAvXo8gJ5aKq1xrspguUXCn8WDml81ONifv0sJn32Zm/pvydwTq8kcfzkTaALLeVcqcbdqgcpHp5KUbq+AXot+cuBgCZcyM8kUH+p1C2ncj3/zWm3tGrcfCgjDp4FTER/+166gjLdN9ijyBbU7RBlVHDIlnvHoy3wWHgCvJrMg+fzv4PeA4WnSXr3bjkcU+/3rX3WHxoumcapiaZvo1P+wpeevcXAcxrMHFfo/kYJCRsaHpxzmBzLSaqLn5Do9ggpslw",
+  "publicKey": "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQm9qQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FZOEFNSUlCaWdLQ0FZRUFzdUhXYUhsZ0I1cVF4ZEJjTlJKSAordHR4SmoxcVY1NTdvMlZaRE1XaXhYRVBkRTBEMVFkT1JIRXNSS1RscmplUXlERU83ZlNQS0ZwZ1A3MU5TTnJCCkFHM2NFSU45aHNQVDhOVmllZmdWem5QTkVMenFkVmdEbFhpb2VpUnV6OERKWFgvblpmU1JWKytwbk9ySTRibG4KS0twelJlNW14OTc1SjhxZ1FvRktKT0NNRlpHdkJMR2MxSzZZaEIzOHJFODZCZzgzbUovWjBEYkVmQjBxZm13cgo2ZDVFUXFsd0E5Y3JZT1YyV1VpWXprSnBLNmJZNzRZNmM1TmpBcEFKeGNiaTFOaDlRVEhUcU44N0ZtMDF0R1ZwCjVNd1pXSWZuYVRUemEvTGZLelR5U0pka0tldEZMVGdkYXpMYlpzUEE2aHBSK0FJRTJhc0tLTi84UUk1N3UzU2cKL2xyMnZKS1IvU2l5eEN1Q20vQWJkYnJMbXk0WjlSdm1jMGdpclA4T0lLQWxBRWZ2TzV5Z2hSKy8vd1RpTFlzUQp1SllDM0V2UE16ZGdKUzdGR2FscnFLZzlPTCsxVzROY05yNWdveVdSUUJ0cktKaWlTZEJVWmVxb0RvSUY5NHpCCndGbzJJT1JFdXFqcU51M3diMWZIM3p1dGdtalFra3IxVjJhd3hmcExLWlROQWdNQkFBRT0KLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg"
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/CHANGELOG.md

@@ -0,0 +1,90 @@
+# Code Editor Package for Visual Studio Code
+
+## [1.2.5] - 2022-02-07
+
+- Introduce OnGeneratedCSProjectFiles, OnGeneratedCSProject and OnGeneratedSlnSolution callbacks.
+- Always use forward slash in source paths
+- Analyzers use absolute paths
+- Ruleset files for roslyn analyzers
+- Extra snap search paths on Ubuntu
+- Specific c# language version for specific unity versions
+- No longer hide .gitignore in VSCode file explorer
+
+
+## [1.2.3] - 2020-10-23
+
+Remove workaround for VSCode omnisharp (as of https://github.com/OmniSharp/omnisharp-vscode/issues/4113 we no longer need to disable the referenceoutputassemblies).
+
+
+## [1.2.2] - 2020-09-04
+
+VSC-14 - synchronize solution file when adding new assembly
+
+
+## [1.2.1] - 2020-05-15
+
+Source filtering adds support for asmref
+
+
+## [1.2.0] - 2020-03-04
+
+Do not reference projects that has not been generated (case 1211057)
+Only open files that exists (case 1188394)
+Add individual toggle buttons for generating csprojects for packages
+Add support for Roslyn analyzers in project generation through csc.rsp and compiled assembly references
+Remove Release build target from csproj and sln
+
+
+## [1.1.4] - 2020-01-02
+
+Delta project generation, only recompute the csproj files whose script modified.
+
+
+## [1.1.3] - 2019-10-22
+
+Exe version of vscode will use Normal ProcessWindowStyle while cmd will use Hidden
+
+
+## [1.1.2] - 2019-08-30
+
+Fixing OSX open command arguments
+
+
+## [1.1.1] - 2019-08-19
+
+Support for Player Project. Generates specific csproj files containing files, reference, defines,
+etc. that will show how the assembly will be compiled for a target platform.
+
+
+## [1.1.0] - 2019-08-07
+
+Adds support for choosing extensions to be opened with VSCode. This can be done through the GUI in Preferences.
+Avoids opening all extensions after the change in core unity.
+
+
+## [1.0.7] - 2019-05-15
+
+Fix various OSX specific issues.
+Generate project on load if they are not generated.
+Fix path recognition.
+
+
+## [1.0.6] - 2019-04-30
+
+Ensure asset database is refreshed when generating csproj and solution files.
+
+## [1.0.5] - 2019-04-27
+
+Add support for generating all csproj files.
+
+## [1.0.4] - 2019-04-18
+
+Fix relative package paths.
+Fix opening editor on mac.
+Add %LOCALAPPDATA%/Programs to the path of install paths.
+
+## [1.0.3] - 2019-01-01
+
+### This is the first release of *Unity Package vscode_editor*.
+
+Using the newly created api to integrate Visual Studio Code with Unity.

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/CHANGELOG.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4ddcdc3816429494a8bea67e973875f7
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/CONTRIBUTING.md

@@ -0,0 +1,6 @@
+# Contributing
+
+## All contributions are subject to the [Unity Contribution Agreement(UCA)](https://unity3d.com/legal/licenses/Unity_Contribution_Agreement)
+By making a pull request, you are confirming agreement to the terms and conditions of the UCA, including that your Contributions are your original creation and that you have complete right and authority to make your Contributions.
+
+## Once you have a change ready following these ground rules. Simply make a pull request

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/CONTRIBUTING.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fcb9be00baf924c4183fc0313e6185c5
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Documentation~/README.md

@@ -0,0 +1,4 @@
+# Code Editor Package for Visual Studio Code
+
+This package is not intended to be modified by users.
+Nor does it provide any api intended to be included in user projects.

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 58628227479c34542ac8c5193ccced84
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c779d3735d950f341ba35154e8b3234b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/AssemblyNameProvider.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Compilation;
+using UnityEditor.PackageManager;
+
+namespace VSCodeEditor
+{
+    public interface IAssemblyNameProvider
+    {
+        string[] ProjectSupportedExtensions { get; }
+        ProjectGenerationFlag ProjectGenerationFlag { get; }
+        string GetAssemblyNameFromScriptPath(string path);
+        IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution);
+        IEnumerable<string> GetAllAssetPaths();
+        IEnumerable<string> GetRoslynAnalyzerPaths();
+        UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath);
+        ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories);
+        bool IsInternalizedPackagePath(string path);
+        void ToggleProjectGeneration(ProjectGenerationFlag preference);
+    }
+
+    internal interface IPackageInfoCache{
+        void ResetPackageInfoCache();
+    }
+
+    internal class AssemblyNameProvider : IAssemblyNameProvider, IPackageInfoCache
+    {
+        private readonly Dictionary<string, UnityEditor.PackageManager.PackageInfo> m_PackageInfoCache = new Dictionary<string, UnityEditor.PackageManager.PackageInfo>();
+
+        ProjectGenerationFlag m_ProjectGenerationFlag = (ProjectGenerationFlag)EditorPrefs.GetInt("unity_project_generation_flag", 0);
+
+        public string[] ProjectSupportedExtensions => EditorSettings.projectGenerationUserExtensions;
+
+        public ProjectGenerationFlag ProjectGenerationFlag
+        {
+            get => m_ProjectGenerationFlag;
+            private set
+            {
+                EditorPrefs.SetInt("unity_project_generation_flag", (int)value);
+                m_ProjectGenerationFlag = value;
+            }
+        }
+
+        public string GetAssemblyNameFromScriptPath(string path)
+        {
+            return CompilationPipeline.GetAssemblyNameFromScriptPath(path);
+        }
+
+        public IEnumerable<Assembly> GetAssemblies(Func<string, bool> shouldFileBePartOfSolution)
+        {
+            return CompilationPipeline.GetAssemblies()
+                .Where(i => 0 < i.sourceFiles.Length && i.sourceFiles.Any(shouldFileBePartOfSolution));
+        }
+
+        public IEnumerable<string> GetAllAssetPaths()
+        {
+            return AssetDatabase.GetAllAssetPaths();
+        }
+
+        private static string ResolvePotentialParentPackageAssetPath(string assetPath)
+		{
+            const string packagesPrefix = "packages/";
+            if (!assetPath.StartsWith(packagesPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                return null;
+            }
+
+            var followupSeparator = assetPath.IndexOf('/', packagesPrefix.Length);
+            if (followupSeparator == -1)
+            {
+                return assetPath.ToLowerInvariant();
+            }
+
+            return assetPath.Substring(0, followupSeparator).ToLowerInvariant();
+		}
+
+        public void ResetPackageInfoCache()
+		{
+			m_PackageInfoCache.Clear();
+		}
+
+        public UnityEditor.PackageManager.PackageInfo FindForAssetPath(string assetPath)
+        {
+            var parentPackageAssetPath = ResolvePotentialParentPackageAssetPath(assetPath);
+			if (parentPackageAssetPath == null)
+			{
+				return null;
+			}
+
+			if (m_PackageInfoCache.TryGetValue(parentPackageAssetPath, out var cachedPackageInfo))
+			{
+				return cachedPackageInfo;
+			}
+
+			var result = UnityEditor.PackageManager.PackageInfo.FindForAssetPath(parentPackageAssetPath);
+			m_PackageInfoCache[parentPackageAssetPath] = result;
+			return result;
+        }
+
+        public ResponseFileData ParseResponseFile(string responseFilePath, string projectDirectory, string[] systemReferenceDirectories)
+        {
+            return CompilationPipeline.ParseResponseFile(
+                responseFilePath,
+                projectDirectory,
+                systemReferenceDirectories
+            );
+        }
+
+        public bool IsInternalizedPackagePath(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+            {
+                return false;
+            }
+            var packageInfo = FindForAssetPath(path);
+            if (packageInfo == null)
+            {
+                return false;
+            }
+            var packageSource = packageInfo.source;
+            switch (packageSource)
+            {
+                case PackageSource.Embedded:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Embedded);
+                case PackageSource.Registry:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Registry);
+                case PackageSource.BuiltIn:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.BuiltIn);
+                case PackageSource.Unknown:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Unknown);
+                case PackageSource.Local:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Local);
+                case PackageSource.Git:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.Git);
+#if UNITY_2019_3_OR_NEWER
+                case PackageSource.LocalTarball:
+                    return !ProjectGenerationFlag.HasFlag(ProjectGenerationFlag.LocalTarBall);
+#endif
+            }
+
+            return false;
+        }
+
+        public void ToggleProjectGeneration(ProjectGenerationFlag preference)
+        {
+            if (ProjectGenerationFlag.HasFlag(preference))
+            {
+                ProjectGenerationFlag ^= preference;
+            }
+            else
+            {
+                ProjectGenerationFlag |= preference;
+            }
+        }
+
+        public IEnumerable<string> GetRoslynAnalyzerPaths()
+        {
+            return PluginImporter.GetAllImporters()
+                .Where(i => !i.isNativePlugin && AssetDatabase.GetLabels(i).SingleOrDefault(l => l == "RoslynAnalyzer") != null)
+                .Select(i => i.assetPath);
+        }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/AssemblyNameProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1d93ffb668978f7488211a331977b73b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/FileIO.cs

@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+using System.Security;
+using System.Text;
+
+namespace VSCodeEditor
+{
+    public interface IFileIO
+    {
+        bool Exists(string fileName);
+
+        string ReadAllText(string fileName);
+        void WriteAllText(string fileName, string content);
+
+        void CreateDirectory(string pathName);
+        string EscapedRelativePathFor(string file, string projectDirectory);
+    }
+
+    class FileIOProvider : IFileIO
+    {
+        public bool Exists(string fileName)
+        {
+            return File.Exists(fileName);
+        }
+
+        public string ReadAllText(string fileName)
+        {
+            return File.ReadAllText(fileName);
+        }
+
+        public void WriteAllText(string fileName, string content)
+        {
+            File.WriteAllText(fileName, content, Encoding.UTF8);
+        }
+
+        public void CreateDirectory(string pathName)
+        {
+            Directory.CreateDirectory(pathName);
+        }
+
+        public string EscapedRelativePathFor(string file, string projectDirectory)
+        {
+            var projectDir = Path.GetFullPath(projectDirectory);
+
+            // We have to normalize the path, because the PackageManagerRemapper assumes
+            // dir seperators will be os specific.
+            var absolutePath = Path.GetFullPath(file.NormalizePath());
+            var path = SkipPathPrefix(absolutePath, projectDir);
+
+            return SecurityElement.Escape(path);
+        }
+
+        private static string SkipPathPrefix(string path, string prefix)
+        {
+            return path.StartsWith($@"{prefix}{Path.DirectorySeparatorChar}", StringComparison.Ordinal)
+                ? path.Substring(prefix.Length + 1)
+                : path;
+        }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/FileIO.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb221cf55b3544646b0c3b6bc790080f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/GUIDGenerator.cs

@@ -0,0 +1,21 @@
+namespace VSCodeEditor
+{
+    public interface IGUIDGenerator
+    {
+        string ProjectGuid(string projectName, string assemblyName);
+        string SolutionGuid(string projectName, string extension);
+    }
+
+    class GUIDProvider : IGUIDGenerator
+    {
+        public string ProjectGuid(string projectName, string assemblyName)
+        {
+            return SolutionGuidGenerator.GuidForProject(projectName + assemblyName);
+        }
+
+        public string SolutionGuid(string projectName, string extension)
+        {
+            return SolutionGuidGenerator.GuidForSolution(projectName, extension); // GetExtensionOfSourceFiles(assembly.sourceFiles)
+        }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/GUIDGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e58bd3cca6475e54b93632bb6837aeea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/ProjectGeneration.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 97d6c87381e3e51488b49f5891490b70
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/ProjectGenerationFlag.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace VSCodeEditor
+{
+    [Flags]
+    public enum ProjectGenerationFlag
+    {
+        None = 0,
+        Embedded = 1,
+        Local = 2,
+        Registry = 4,
+        Git = 8,
+        BuiltIn = 16,
+        Unknown = 32,
+        PlayerAssemblies = 64,
+        LocalTarBall = 128,
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/ProjectGenerationFlag.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f239f506223a98f4e9b5dd3a9f80edea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/StringUtils.cs

@@ -0,0 +1,26 @@
+using System.IO;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Unity.VSCode.EditorTests")]
+
+namespace VSCodeEditor
+{
+    internal static class StringUtils
+    {
+        private const char WinSeparator = '\\';
+        private const char UnixSeparator = '/';
+
+        public static string NormalizePath(this string path)
+        {
+            if (string.IsNullOrEmpty(path))
+                return path;
+
+            if (Path.DirectorySeparatorChar == WinSeparator)
+                path = path.Replace(UnixSeparator, WinSeparator);
+            if (Path.DirectorySeparatorChar == UnixSeparator)
+                path = path.Replace(WinSeparator, UnixSeparator);
+
+            return path.Replace(string.Concat(WinSeparator, WinSeparator), WinSeparator.ToString());
+        }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/ProjectGeneration/StringUtils.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ee022071da7e4040bf2f949e15926ba1
+timeCreated: 1624968755

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/Unity.com.unity.vscode.Editor.asmdef

@@ -0,0 +1,26 @@
+{
+    "name": "Unity.VSCode.Editor",
+    "references": [],
+    "optionalUnityReferences": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "versionDefines": [
+        {
+            "name": "Unity",
+            "expression": "2021.2.0a9",
+            "define": "ROSLYN_ANALYZER_FIX"
+        },
+        {
+            "name": "Unity",
+            "expression": "[2021.1.2f1,2021.2.0a1]",
+            "define": "ROSLYN_ANALYZER_FIX"
+        },
+        {
+            "name": "Unity",
+            "expression": "[2020.3.6f1,2021.0]",
+            "define": "ROSLYN_ANALYZER_FIX"
+        }
+    ]
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/Unity.com.unity.vscode.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8b845b123ab418448a8be2935fa804e0
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/VSCodeDiscovery.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Unity.CodeEditor;
+
+namespace VSCodeEditor
+{
+    public interface IDiscovery
+    {
+        CodeEditor.Installation[] PathCallback();
+    }
+
+    public class VSCodeDiscovery : IDiscovery
+    {
+        List<CodeEditor.Installation> m_Installations;
+
+        public CodeEditor.Installation[] PathCallback()
+        {
+            if (m_Installations == null)
+            {
+                m_Installations = new List<CodeEditor.Installation>();
+                FindInstallationPaths();
+            }
+
+            return m_Installations.ToArray();
+        }
+
+        void FindInstallationPaths()
+        {
+            string[] possiblePaths =
+#if UNITY_EDITOR_OSX
+            {
+                "/Applications/Visual Studio Code.app",
+                "/Applications/Visual Studio Code - Insiders.app"
+            };
+#elif UNITY_EDITOR_WIN
+            {
+                GetProgramFiles() + @"/Microsoft VS Code/bin/code.cmd",
+                GetProgramFiles() + @"/Microsoft VS Code/Code.exe",
+                GetProgramFiles() + @"/Microsoft VS Code Insiders/bin/code-insiders.cmd",
+                GetProgramFiles() + @"/Microsoft VS Code Insiders/Code.exe",
+                GetLocalAppData() + @"/Programs/Microsoft VS Code/bin/code.cmd",
+                GetLocalAppData() + @"/Programs/Microsoft VS Code/Code.exe",
+                GetLocalAppData() + @"/Programs/Microsoft VS Code Insiders/bin/code-insiders.cmd",
+                GetLocalAppData() + @"/Programs/Microsoft VS Code Insiders/Code.exe",
+            };
+#else
+            {
+                "/usr/bin/code",
+                "/bin/code",
+                "/usr/local/bin/code",
+                "/var/lib/flatpak/exports/bin/com.visualstudio.code",
+                "/snap/current/bin/code",
+                "/snap/bin/code"
+            };
+#endif
+            var existingPaths = possiblePaths.Where(VSCodeExists).ToList();
+            if (!existingPaths.Any())
+            {
+                return;
+            }
+
+            var lcp = GetLongestCommonPrefix(existingPaths);
+            switch (existingPaths.Count)
+            {
+                case 1:
+                {
+                    var path = existingPaths.First();
+                    m_Installations = new List<CodeEditor.Installation>
+                    {
+                        new CodeEditor.Installation
+                        {
+                            Path = path,
+                            Name = path.Contains("Insiders")
+                                ? "Visual Studio Code Insiders"
+                                : "Visual Studio Code"
+                        }
+                    };
+                    break;
+                }
+                case 2 when existingPaths.Any(path => !(path.Substring(lcp.Length).Contains("/") || path.Substring(lcp.Length).Contains("\\"))):
+                {
+                    goto case 1;
+                }
+                default:
+                {
+                    m_Installations = existingPaths.Select(path => new CodeEditor.Installation
+                    {
+                        Name = $"Visual Studio Code Insiders ({path.Substring(lcp.Length)})",
+                        Path = path
+                    }).ToList();
+
+                    break;
+                }
+            }
+        }
+
+#if UNITY_EDITOR_WIN
+        static string GetProgramFiles()
+        {
+            return Environment.GetEnvironmentVariable("ProgramFiles")?.Replace("\\", "/");
+        }
+
+        static string GetLocalAppData()
+        {
+            return Environment.GetEnvironmentVariable("LOCALAPPDATA")?.Replace("\\", "/");
+        }
+#endif
+
+        static string GetLongestCommonPrefix(List<string> paths)
+        {
+            var baseLength = paths.First().Length;
+            for (var pathIndex = 1; pathIndex < paths.Count; pathIndex++)
+            {
+                baseLength = Math.Min(baseLength, paths[pathIndex].Length);
+                for (var i = 0; i < baseLength; i++)
+                {
+                    if (paths[pathIndex][i] == paths[0][i]) continue;
+
+                    baseLength = i;
+                    break;
+                }
+            }
+
+            return paths[0].Substring(0, baseLength);
+        }
+
+        static bool VSCodeExists(string path)
+        {
+#if UNITY_EDITOR_OSX
+            return System.IO.Directory.Exists(path);
+#else
+            return new FileInfo(path).Exists;
+#endif
+        }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/VSCodeDiscovery.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 380f7372e785c7d408552e2c760d269d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/VSCodeScriptEditor.cs

@@ -0,0 +1,282 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Diagnostics;
+using UnityEditor;
+using UnityEngine;
+using Unity.CodeEditor;
+
+namespace VSCodeEditor
+{
+    [InitializeOnLoad]
+    public class VSCodeScriptEditor : IExternalCodeEditor
+    {
+        const string vscode_argument = "vscode_arguments";
+        const string vscode_extension = "vscode_userExtensions";
+        static readonly GUIContent k_ResetArguments = EditorGUIUtility.TrTextContent("Reset argument");
+        string m_Arguments;
+
+        IDiscovery m_Discoverability;
+        IGenerator m_ProjectGeneration;
+
+        static readonly string[] k_SupportedFileNames = { "code.exe", "visualstudiocode.app", "visualstudiocode-insiders.app", "vscode.app", "code.app", "code.cmd", "code-insiders.cmd", "code", "com.visualstudio.code" };
+
+        static bool IsOSX => Application.platform == RuntimePlatform.OSXEditor;
+
+        static string DefaultApp => EditorPrefs.GetString("kScriptsDefaultApp");
+
+        static string DefaultArgument { get; } = "\"$(ProjectPath)\" -g \"$(File)\":$(Line):$(Column)";
+
+        string Arguments
+        {
+            get => m_Arguments ?? (m_Arguments = EditorPrefs.GetString(vscode_argument, DefaultArgument));
+            set
+            {
+                m_Arguments = value;
+                EditorPrefs.SetString(vscode_argument, value);
+            }
+        }
+
+        static string[] defaultExtensions
+        {
+            get
+            {
+                var customExtensions = new[] { "json", "asmdef", "log" };
+                return EditorSettings.projectGenerationBuiltinExtensions
+                    .Concat(EditorSettings.projectGenerationUserExtensions)
+                    .Concat(customExtensions)
+                    .Distinct().ToArray();
+            }
+        }
+
+        static string[] HandledExtensions
+        {
+            get
+            {
+                return HandledExtensionsString
+                    .Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(s => s.TrimStart('.', '*'))
+                    .ToArray();
+            }
+        }
+
+        static string HandledExtensionsString
+        {
+            get => EditorPrefs.GetString(vscode_extension, string.Join(";", defaultExtensions));
+            set => EditorPrefs.SetString(vscode_extension, value);
+        }
+
+        public bool TryGetInstallationForPath(string editorPath, out CodeEditor.Installation installation)
+        {
+            var lowerCasePath = editorPath.ToLower();
+            var filename = Path.GetFileName(lowerCasePath).Replace(" ", "");
+            var installations = Installations;
+            if (!k_SupportedFileNames.Contains(filename))
+            {
+                installation = default;
+                return false;
+            }
+
+            if (!installations.Any())
+            {
+                installation = new CodeEditor.Installation
+                {
+                    Name = "Visual Studio Code",
+                    Path = editorPath
+                };
+            }
+            else
+            {
+                try
+                {
+                    installation = installations.First(inst => inst.Path == editorPath);
+                }
+                catch (InvalidOperationException)
+                {
+                    installation = new CodeEditor.Installation
+                    {
+                        Name = "Visual Studio Code",
+                        Path = editorPath
+                    };
+                }
+            }
+
+            return true;
+        }
+
+        public void OnGUI()
+        {
+            Arguments = EditorGUILayout.TextField("External Script Editor Args", Arguments);
+            if (GUILayout.Button(k_ResetArguments, GUILayout.Width(120)))
+            {
+                Arguments = DefaultArgument;
+            }
+
+            EditorGUILayout.LabelField("Generate .csproj files for:");
+            EditorGUI.indentLevel++;
+            SettingsButton(ProjectGenerationFlag.Embedded, "Embedded packages", "");
+            SettingsButton(ProjectGenerationFlag.Local, "Local packages", "");
+            SettingsButton(ProjectGenerationFlag.Registry, "Registry packages", "");
+            SettingsButton(ProjectGenerationFlag.Git, "Git packages", "");
+            SettingsButton(ProjectGenerationFlag.BuiltIn, "Built-in packages", "");
+#if UNITY_2019_3_OR_NEWER
+            SettingsButton(ProjectGenerationFlag.LocalTarBall, "Local tarball", "");
+#endif
+            SettingsButton(ProjectGenerationFlag.Unknown, "Packages from unknown sources", "");
+            RegenerateProjectFiles();
+            EditorGUI.indentLevel--;
+
+            HandledExtensionsString = EditorGUILayout.TextField(new GUIContent("Extensions handled: "), HandledExtensionsString);
+        }
+
+        void RegenerateProjectFiles()
+        {
+            var rect = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(new GUILayoutOption[] { }));
+            rect.width = 252;
+            if (GUI.Button(rect, "Regenerate project files"))
+            {
+                m_ProjectGeneration.Sync();
+            }
+        }
+
+        void SettingsButton(ProjectGenerationFlag preference, string guiMessage, string toolTip)
+        {
+            var prevValue = m_ProjectGeneration.AssemblyNameProvider.ProjectGenerationFlag.HasFlag(preference);
+            var newValue = EditorGUILayout.Toggle(new GUIContent(guiMessage, toolTip), prevValue);
+            if (newValue != prevValue)
+            {
+                m_ProjectGeneration.AssemblyNameProvider.ToggleProjectGeneration(preference);
+            }
+        }
+
+        public void CreateIfDoesntExist()
+        {
+            if (!m_ProjectGeneration.SolutionExists())
+            {
+                m_ProjectGeneration.Sync();
+            }
+        }
+
+        public void SyncIfNeeded(string[] addedFiles, string[] deletedFiles, string[] movedFiles, string[] movedFromFiles, string[] importedFiles)
+        {
+            (m_ProjectGeneration.AssemblyNameProvider as IPackageInfoCache)?.ResetPackageInfoCache();
+            m_ProjectGeneration.SyncIfNeeded(addedFiles.Union(deletedFiles).Union(movedFiles).Union(movedFromFiles).ToList(), importedFiles);
+        }
+
+        public void SyncAll()
+        {
+            (m_ProjectGeneration.AssemblyNameProvider as IPackageInfoCache)?.ResetPackageInfoCache();
+            AssetDatabase.Refresh();
+            m_ProjectGeneration.Sync();
+        }
+
+        public bool OpenProject(string path, int line, int column)
+        {
+            if (path != "" && (!SupportsExtension(path) || !File.Exists(path))) // Assets - Open C# Project passes empty path here
+            {
+                return false;
+            }
+
+            if (line == -1)
+                line = 1;
+            if (column == -1)
+                column = 0;
+
+            string arguments;
+            if (Arguments != DefaultArgument)
+            {
+                arguments = m_ProjectGeneration.ProjectDirectory != path
+                    ? CodeEditor.ParseArgument(Arguments, path, line, column)
+                    : m_ProjectGeneration.ProjectDirectory;
+            }
+            else
+            {
+                arguments = $@"""{m_ProjectGeneration.ProjectDirectory}""";
+                if (m_ProjectGeneration.ProjectDirectory != path && path.Length != 0)
+                {
+                    arguments += $@" -g ""{path}"":{line}:{column}";
+                }
+            }
+
+            if (IsOSX)
+            {
+                return OpenOSX(arguments);
+            }
+
+            var app = DefaultApp;
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = app,
+                    Arguments = arguments,
+                    WindowStyle = app.EndsWith(".cmd", StringComparison.OrdinalIgnoreCase) ? ProcessWindowStyle.Hidden : ProcessWindowStyle.Normal,
+                    CreateNoWindow = true,
+                    UseShellExecute = true,
+                }
+            };
+
+            process.Start();
+            return true;
+        }
+
+        static bool OpenOSX(string arguments)
+        {
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo
+                {
+                    FileName = "open",
+                    Arguments = $"-n \"{DefaultApp}\" --args {arguments}",
+                    UseShellExecute = true,
+                }
+            };
+
+            process.Start();
+            return true;
+        }
+
+        static bool SupportsExtension(string path)
+        {
+            var extension = Path.GetExtension(path);
+            if (string.IsNullOrEmpty(extension))
+                return false;
+            return HandledExtensions.Contains(extension.TrimStart('.'));
+        }
+
+        public CodeEditor.Installation[] Installations => m_Discoverability.PathCallback();
+
+        public VSCodeScriptEditor(IDiscovery discovery, IGenerator projectGeneration)
+        {
+            m_Discoverability = discovery;
+            m_ProjectGeneration = projectGeneration;
+        }
+
+        static VSCodeScriptEditor()
+        {
+            var editor = new VSCodeScriptEditor(new VSCodeDiscovery(), new ProjectGeneration(Directory.GetParent(Application.dataPath).FullName));
+            CodeEditor.Register(editor);
+
+            if (IsVSCodeInstallation(CodeEditor.CurrentEditorInstallation))
+            {
+                editor.CreateIfDoesntExist();
+            }
+        }
+
+        static bool IsVSCodeInstallation(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                return false;
+            }
+
+            var lowerCasePath = path.ToLower();
+            var filename = Path
+                .GetFileName(lowerCasePath.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar))
+                .Replace(" ", "");
+            return k_SupportedFileNames.Contains(filename);
+        }
+
+        public void Initialize(string editorInstallationPath) { }
+    }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/Editor/VSCodeScriptEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ac3f13489022aa34d861a0320a6917b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Unity Technologies
+
+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.

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c9aabac5924106d4790d7b3a924ca34d
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/ValidationExceptions.json

@@ -0,0 +1,10 @@
+{
+    "ErrorExceptions": [
+        {
+            "ValidationTest": "API Validation",
+            "ExceptionMessage": "Additions require a new minor or major version.",
+            "PackageVersion": "1.2.3"
+        }
+    ],
+    "WarningExceptions": []
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/ValidationExceptions.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fc368c32d6432ff4bb374d520000749c
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "com.unity.ide.vscode",
+  "displayName": "Visual Studio Code Editor",
+  "description": "Code editor integration for supporting Visual Studio Code as code editor for unity. Adds support for generating csproj files for intellisense purposes, auto discovery of installations, etc.",
+  "version": "1.2.5",
+  "unity": "2019.2",
+  "unityRelease": "0a12",
+  "relatedPackages": {
+    "com.unity.ide.vscode.tests": "1.2.5"
+  },
+  "upmCi": {
+    "footprint": "bc03b7bb076199fbe68649a647d0d32d98af6a0f"
+  },
+  "repository": {
+    "url": "https://github.com/Unity-Technologies/com.unity.ide.vscode.git",
+    "type": "git",
+    "revision": "b0740c80bfc2440527c317109f7c3d9100132722"
+  }
+}

Droid 2/Library/PackageCache/com.unity.ide.vscode@1.2.5/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ffc6271f08270b64ca0aae9c49235d81
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: